[alg] fraaiste prog voorbeelden.

[dusty]

code:

10 DO
20   PRINT "AlarmNummer is een pruts0r"
30 LOOP WHILE 1=1

[Alarmnummer]

dusty schreef op 12 April 2003 @ 17:56:

code:

10 DO
20   PRINT "AlarmNummer is een pruts0r"
30 LOOP WHILE 1=1

Lukt het je ook nog om dat te onderbouwen? Of is al je creativiteit hier al in komen te zitten

[alienfruit]

Idd. Er is geen standaard voor een binaire (compacte) uitwisselingsvorm van XML. Er zijn echter wel veel ideeen (en uitwerkingen) in die richting. Ik acht de kans echter niet erg groot dat er binnen afzienbare tijd een standaard voor XML zal komen.

Ja, Nu wordt in onder andere SOAP base64 encoding gebruikt voor het meesturen van attachments/binaire data; betekend toch dat de xml twee/drie keer zo groot wordt dan orginele binaire bestand

Dat is dan niet bij dat nieuwe formaat?!?!

[hobbit_be]

{offtopic / ontopic regarding binary xml}

zullen we samen es een commisie oprichten? zo moeilijk is dat formaat ECHT niet kan men
in een dagje implementeren... 'gat in de markt'?

[dusty]

Alarmnummer schreef op 12 april 2003 @ 18:31:
[...]


Lukt het je ook nog om dat te onderbouwen? Of is al je creativiteit hier al in komen te zitten

Zelfde functionaliteit, minimale bytes die extra worden verbruikt t.o.v. jouw code echter wordt er geen jump gebruikt waardoor je wiskundig kan aantonen dat het programma precies doet wat het hoort te doen, met jouw methode kan je alleen aantonen met benadering dat je programma doet wat het hoort ( dus kan je niet 100% wiskundig bevestigen dat je programma exact doet wat het hoort te doen.)

[EfBe]

dusty schreef op 13 april 2003 @ 13:21:
Zelfde functionaliteit, minimale bytes die extra worden verbruikt t.o.v. jouw code echter wordt er geen jump gebruikt waardoor je wiskundig kan aantonen dat het programma precies doet wat het hoort te doen, met jouw methode kan je alleen aantonen met benadering dat je programma doet wat het hoort ( dus kan je niet 100% wiskundig bevestigen dat je programma exact doet wat het hoort te doen.)

Nerd

[Verwijderd]

/me *

ik ben de afgelopen dagen bezig geweest met colourspace conversion routines voor een media library waar ik al enkele jaren aan werk. Hierbij moet je denken aan conversies tussen RGB (datgene waar je beeldscherm is opgebouwd) - packed, YUV/Y'Cb'Cr (vwordt veel voor video gebruikt) - zowel packed als planar, eventueel later uitbreidbaar met CMYK (wordt soms in de graphics industrie gebruikt). Het lullige is dat er werkelijk tig van die formaten zijn, waarbij je zelfs als je alleen de meest standaard formaten in beschouwing neemt, je al op meer dan tien formaten komt (YUV9 (bv. Sorensen), YUY2 (bv. MJPEG), I420 (bv. MPEG), IYU2 (professioneel, non-subsampled), RGB-32/24/16/15 BE/LE (alle native RGB formaten). Oftewel, een any-to-any convertor moet generieke routines hebben (en daarnaast gespecialiseerde routines voor conversies die vaak voorkomen). Zeker als je later ook de meer gespecialiseerde formaten zoals Y41P, YVU9, UYVY, YVYU e.d. wilt supporten. Voor gedetailleerde informatie over elk van deze formaten, zie http://www.fourcc.org/.

Kortgezegd, het verschil tussen deze formaten zit in het volgende:
• planar of packed - planar betekent dat eerst alle componenten van het ene type komen, dan alle componenten van de andere. Bij packed komen ze door elkaar heen in groepen (GOPCs, Group Of Pixel Component, als variant op de MPEG GOP (Group Of Pictures)).
• component subsampling - bij YUV9 komen bijvoorbeeld voor elke 4x4 Ys slechts 1 U en V component. Het formaat heet dan ook alternatief "YUV-4:1:0 planar". Je hebt ook YUV-4:1:1 planar (Y41B), waarbij alleen horizontaal 4x gesubsampled is.
• component bitdepth - RGB16 heeft bijvoorbeeld 5 Red/Blue bits en 6 Green bits, terwijl RGBA32 er 8 heeft voor elk, plus nog 8 voor alpha.

Ik moet nu dus routines schrijven om dit alles te kunnen zonder specifiek een formaat te bschrijven. Nu zal ik niet alle code hier neerpoten, maar eentje kon ik jullie toch niet onthouden. Ik heb - in plaats van per-formaat - een per-type conversie schema gemaakt. Hiervoor heb ik slechts 9 functies nodig, omdat ik slechts 3 formaat types heb (YUV-planar, YUV-packed en RGB-packed). Hieronder volgt, bij wijze van voorbeeld, de RGB-to-RGB routine, incl. structures en pre-defined datatypes. Code is nog niet getest overigens, dus misschien zit er een schandalige fout in, maar dat zien we later wel weer. .

Even wat algemene info over RGB: RGB is niet byte aligned, en de endianness staat niet vast. Dat maakt 't een enorm irritant formaat, omdat de eigenlijke byte layout (in een array van unsigned char's) dus omgekeerd kan zijn dan zoals 't eigenlijk hoort. RGB15 ziet er bv zo uit in LE: GGGBBBBBxRRRRRGG. Toevalligerwijs is dit per ongeluk niet zo bij RGB24/32, omdat de components dan elk 8-bit zijn, maar omdat je in de toekomst ook extendible wil zijn naar de bestaande 10-bit formaten en de opkomende 16-bit formaten (oh, the horror - dan krijg je dus per-component endianness issues als je binary gaat lezen ), lezen we alles toch maar in via conversie naar de host endianness order. Hierna halen we via een on-the-fly gecreeerde colour mask de kleurcomponent eruit die we willen hebben en die resamplen we, waarna we hem weer terug omzetten naar de benodigde endianness (niet per se host endianness).

Ohja, de functie declaraties staan al vast, omdat dat nou eenmaal zo in de colourspace conversion routine library is vastgelegd, dat kan ik ook niet helpen... De code hieronder is trouwens samengeplompt tussen verschillende source en header files, in 't echt staat al dit gewoon over meerdere filetjes uitgetypt. . Last but not least, code is licensed under LGPL en (c) ikke. .

C:

#define LCS_MAX_PLANES 4

/* RGB array order */
#define LCS_R   0
#define LCS_G   1
#define LCS_B   2
#define LCS_A   3
#define LCS_RGB_COMPONENTS 4

typedef enum {
  /* planar YUV */
  LCS_FORMAT_YUV_PLANAR = 0,

  /* packed YUV */
  LCS_FORMAT_YUV_PACKED = 1,

  /* packed RGB */
  LCS_FORMAT_RGB_PACKED = 2
} LCSFormatType;

typedef struct _LCSFormat {
  /* format type */
  LCSFormatType type;

  /* bits per pixel, total */
  unsigned int bits_per_pixel;
} LCSFormat;

typedef struct _LCSRGBPackedFormat {
  LCSFormat parent;

  /* position of component (in given endianness) */
  unsigned int component_bit_offset[LCS_RGB_COMPONENTS],
               bits_per_component[LCS_RGB_COMPONENTS];

  /* endianness */
  LCSEndianness endianness;
} LCSRGBPackedFormat;

/*
 * routines for reading/writing RGB bytes to/from host endianness
 */

static inline void
lcs_fallback_rgb_read_pixel (const unsigned char *buf,
                 unsigned long long  *num,
                 unsigned long        size,
                 LCSEndianness        endianness)
{
  /* move one pixel internally into our own byte order,
   * so that the pixel is in the lowest bytes of the integer */
  if (endianness == LCS_BYTE_ORDER) {
#if (LCS_BYTE_ORDER == LCS_BIG_ENDIAN)
    memcpy (((unsigned char *) num) + sizeof (*num) - size, buf, size);
#else
    memcpy (num, buf, size);
#endif
  } else {
    unsigned int n;
    *num = 0;
    for (n = 0; n < size; n++) {
#if (LCS_BYTE_ORDER == LCS_BIG_ENDIAN)
      /* first byte is highest */
      *num |= buf[n] << ((size - 1 - n) * 8);
#else
      /* first byte is lowest */
      *num |= buf[n] << (n * 8);
#endif
    }
  }
}

static inline void
lcs_fallback_rgb_write_pixel (unsigned char            *buf,
                  const unsigned long long  num,
                  unsigned long             size,
                  LCSEndianness             endianness)
{
  /* move one host-byte-order pixel into the requested byte order */
  if (endianness == LCS_BYTE_ORDER) {
#if (LCS_BYTE_ORDER == LCS_BIG_ENDIAN)
    memcpy (buf, ((const unsigned char *) &num) + sizeof (num) - size, size);
#else
    memcpy (buf, num, size);
#endif
  } else {
    unsigned int n;
    for (n = 0; n < size; n++) {
#if (LCS_BYTE_ORDER == LCS_BIG_ENDIAN)
      /* first byte is highest */
      buf[n] = (num >> ((size - 1 - n) * 8)) & 0xff;
#else
      /* first byte is lowest */
      buf[n] = (num >> (size * 8)) & 0xff;
#endif
    }
  }
}

/*
 * extract a component from a RGB pixel
 */

static inline unsigned int
lcs_fallback_rgb_pixel_extract_component (unsigned long long rgb_pixel,
                      unsigned int       bit_size,
                      unsigned int       bit_offset)
{
  return (rgb_pixel >> bit_offset) & ((1 << bit_size) - 1);
}

/*
 * resample a RGB pixel component
 */

static inline unsigned int
lcs_fallback_rgb_pixel_resample_component (unsigned int component,
                       unsigned int from_bitsize,
                       unsigned int to_bitsize)
{
  if (from_bitsize >= to_bitsize) {
    /* Bitshifting. We lose significance but that's the whole
     * point of downsampling so it doesn't matter. */
    return component >> (from_bitsize - to_bitsize);
  } else {
    /* simple bit-shifting isn't enough, we'll loose the lowest
     * bits then, which means that 0xff would become 0xff00 instead
     * of 0xffff. So we multiply. There's still a rounding error,
     * but we don't care. */
    return (component * ((1 << to_bitsize) - 1)) / ((1 << from_bitsize) - 1);
  }
}

/*
 * put a component back into a pixel
 */

static inline unsigned long long
lcs_fallback_rgb_pixel_insert_component (unsigned int component,
                     unsigned int bit_size,
                     unsigned int bit_offset)
{
  return (component & ((1 << bit_size) - 1)) << bit_offset;
}

LCSResult
lcs_fallback_rgbpacked_to_rgbpacked_wrap_c (LCSConverter        *converter,
                        const unsigned char *src[LCS_MAX_PLANES],
                        unsigned char       *dest[LCS_MAX_PLANES],
                        const unsigned int   src_stride[LCS_MAX_PLANES],
                        const unsigned int   dest_stride[LCS_MAX_PLANES],
                        unsigned int         width,
                        unsigned int         height)
{
  LCSRGBPackedFormat *src_fmt, *dest_fmt;
  unsigned int x, y, n;
  const unsigned char *src_row;
  unsigned char *dest_row;
  unsigned long long src_pixel, dest_pixel;
  unsigned long src_bytes, dest_bytes;

  /* format shortcuts */
  src_fmt  = (LCSRGBPackedFormat *) lcs_converter_get_src_format (converter);
  dest_fmt = (LCSRGBPackedFormat *) lcs_converter_get_dest_format (converter);
  src_bytes  = ((LCSFormat *) src_fmt)->bits_per_pixel >> 3;
  dest_bytes = ((LCSFormat *) dest_fmt)->bits_per_pixel >> 3;

  for (y = 0; y < height; y++) {
    /* set our own position within */
    src_row  = &src[0][y * src_stride[0]];
    dest_row = &dest[0][y * dest_stride[0]];

    for (x = 0; x < width; x++) {
      lcs_fallback_rgb_read_pixel (&src_row[src_bytes * x],
                   &src_pixel, src_bytes,
                   src_fmt->endianness);

      /* some explanation on the routine below...
       * We're going to isolate the four pixel components,
       * R/G/B/A. First, we'll shift these to the left (so that
       * they become elementary, with their components' LSB
       * being 1). Then, we create a mask based on their BPC
       * and apply it to this value. We now have the component's
       * individual value.
       * Next, we change the BPC of this (by shifting it to the
       * left/right), so that we're now working in the dest_fmt's
       * BPC count, and shift this to the left of its offset
       * in the dest format. And if we do this for all R/G/B/A
       * together, we've converted one pixel!
       */
      dest_pixel = 0;
      for (n = 0; n < LCS_RGB_COMPONENTS; n++) {
        dest_pixel |= lcs_fallback_rgb_pixel_insert_component (
              lcs_fallback_rgb_pixel_resample_component (
                  lcs_fallback_rgb_pixel_extract_component (
                  src_pixel,
                  src_fmt->bits_per_component[n],
                  src_fmt->component_bit_offset[n]),
                  src_fmt->bits_per_component[n],
                  dest_fmt->bits_per_component[n]),
              dest_fmt->bits_per_component[n],
              dest_fmt->component_bit_offset[n]);
      }

      lcs_fallback_rgb_write_pixel (&dest_row[dest_bytes * x],
                    dest_pixel, dest_bytes,
                    dest_fmt->endianness);
    }
  }

  return LCS_RESULT_OK;
}

Als laatste nog enkele voorbeelden van RGB formaten die je hiermee kan omzetten (pre-defined):

C:

static const struct {
  char *name;
  LCSRGBPackedFormat fmt;
} rgb_formats[] = {
  /* 32 bit formats with 8-bit transparency */
  { "RGBA8888_BE", { { LCS_FORMAT_RGB_PACKED, 32 },
             { 24, 16, 8, 0 }, { 8, 8, 8, 8 }, LCS_BIG_ENDIAN } },
  { "RGBA8888_LE", { { LCS_FORMAT_RGB_PACKED, 32 },
             { 24, 16, 8, 0 }, { 8, 8, 8, 8 }, LCS_LITTLE_ENDIAN } },

  /* 32 bit formats without transparency (i.e. 24-bit padded) */
  { "XRGB8888_BE", { { LCS_FORMAT_RGB_PACKED, 32 },
             { 16, 8, 0, 0 }, { 8, 8, 8, 0 }, LCS_BIG_ENDIAN } },
  { "XRGB8888_LE", { { LCS_FORMAT_RGB_PACKED, 32 },
             { 16, 8, 0, 0 }, { 8, 8, 8, 0 }, LCS_LITTLE_ENDIAN } },

  /* 24 bit formats */
  { "RGB888_BE", { { LCS_FORMAT_RGB_PACKED, 24 },
           { 16, 8, 0, 0 }, { 8, 8, 8, 0 }, LCS_BIG_ENDIAN } },
  { "RGB888_LE", { { LCS_FORMAT_RGB_PACKED, 24 },
           { 16, 8, 0, 0 }, { 8, 8, 8, 0 }, LCS_LITTLE_ENDIAN } },

  /* 16 bit formats */
  { "RGB565_BE", { { LCS_FORMAT_RGB_PACKED, 16 },
           { 11, 5, 0, 0 }, { 5, 6, 5, 0 }, LCS_BIG_ENDIAN } },
  { "RGB565_LE", { { LCS_FORMAT_RGB_PACKED, 16 },
           { 11, 5, 0, 0 }, { 5, 6, 5, 0 }, LCS_LITTLE_ENDIAN } },

  /* 16 bit formats with 1-bit transparency */
  { "RGBA5551_BE", { { LCS_FORMAT_RGB_PACKED, 16 },
           { 11, 6, 1, 0 }, { 5, 5, 5, 1 }, LCS_BIG_ENDIAN } },
  { "RGBA5551_LE", { { LCS_FORMAT_RGB_PACKED, 16 },
           { 11, 6, 1, 0 }, { 5, 5, 5, 1 }, LCS_LITTLE_ENDIAN } },

  /* 15 bit formats */
  { "XRGB1565_BE", { { LCS_FORMAT_RGB_PACKED, 16 },
             { 10, 5, 0, 0 }, { 5, 5, 5, 0 }, LCS_BIG_ENDIAN } },
  { "XRGB1565_LE", { { LCS_FORMAT_RGB_PACKED, 16 },
             { 10, 5, 0, 0 }, { 5, 5, 5, 0 }, LCS_LITTLE_ENDIAN } },

  /* 8 bit formats */
  { "RGB323", { { LCS_FORMAT_RGB_PACKED, 8 },
        { 5, 3, 0, 0 }, { 3, 2, 3, 0 }, LCS_NO_ENDIANNESS } },

  /* FILL ME */
  { NULL, }
};

Ik vind dit toch best wel mooi, en dus een topickick waard. .

[bigtree]

Aangezien ik ook in het 'andere' topic heb gepost, kan ik hierin niet achterblijven. Mijn fraaiste stukje code valt te bewonderen (in het commentaar) op php.net. Voor een kalender-script moest ik kunnen berekenen op welke dag pasen valt in een willekeurig jaar. Daar heeft php een standaard functie voor, maar de library waar die in zit wordt niet standaard meegecompileerd. Mijn functie was uit nood geboren zeg maar. Vergelijk het voor de grap met de andere functie uit de comments...

[Verwijderd]

Dit is mijn code voor een MCMC sampler van een dirichlet posterior, onder gelijk en ongelijkheids restricties.

Het probleem dat er mee wordt opgelost is de volgende:

Een arts keurt kinderen met astma. Dit is een dure tijdsintensieve aangelegenheid. De vraag is of een vragenlijst bestaat, die de arts kan vervangen. Een vragenlijst is ontworpen, waarbij kinden met astma voor een aantal items moeten aangeven of dit voor hen van toepassing is of niet. De test is over een periode meerdere malen afgenomen. We modelleren de uitkomsten van deze test per kind als het product van een set binomiaal processen.

De arts keurt het kind ook na elke test, en geeft een prognose voor herstel. Deze prognose kan worden vertaald in ongelijkheid en gelijkheids restricties op de parameters van het model. Bv het kind gaat vooruit, of, het kind blijft eerst stabiel, en daarna gaat het beter.

We kijken vervolgens of het door de arts voorspelde patroon overeen komt met de uitkomsten van de vragenlijst.


In de code worden de restricties berekend, en daarna worden de parameters van het model onder de (on)gelijkheden gesampeld.

Fortran:

!########################## restrictions ###################################

            data2(i,:)   =matmul(data1(i,:)   ,  equal(:,:,j))              !
            tot_items1   =matmul(tot_items    ,  equal(:,:,j))              !
            par(:,j)     =matmul(par(:,j)     ,  equal(:,:,j))              !handle equality constraints
            alpha(:,j)   =matmul(alpha(:,j)   ,  equal(:,:,j))              !
            beta(:,j)    =matmul(beta(:,j)    ,  equal(:,:,j))              !
            post=0
            do k=1,iterations                                                !do for all iterations
                do l=1,size(par,1)                                          !do for all parameters
                    mask1(:)=.true. ;mask1(l)=.false.                       !
                    lbound1=0; ubound1=1
                        
                    lbound1=maxval((par(:,j)  * lower(l,:,j)),mask=mask1 )    !calulate bounds
                    ubound1=minval((par(:,j)  * upper(l,:,j)),mask=(mask1 .and. upper(l,:,j)>0) )   
                    if (ubound1>1000000000) ubound1=1

!########################## sampling #######################################

                    call drnun(1,unif)                                      ! random number
                    post_a=alpha(l,j)+data2    (i,l)                          ! parameters for posterior
                    post_b=beta (l,j)+tot_items1(l)  -data2(i,l)              !

                    if (post_a >0 .and. post_b>0) then
                        par(l,j)=dbetin((dbetdf(lbound1,post_a,post_b))+ &    ! transform uniform to beta 
                                 unif*(dbetdf(ubound1,post_a,post_b)-dbetdf(lbound1,post_a,post_b)),post_a,post_b)
                    end if

                    par(:,j)=matmul(par(:,j),transpose(equal(:,:,j)))         !rebuild parameters according to equality
                
                    if (k>burnin) post(:,k-burnin)=par(:,j)              !save sample
 
    

[Zoijar]

M'n nieuwe grid class:

C++:

template <
    class FormatPolicy = Raw16Format,
    class SourcePolicy = StreamSource,
    template <class Format, class Source> 
        class CachingPolicy = NoCache,
    class IndexPolicy = CartesianIndex
>
class Grid :
    public CachingPolicy<FormatPolicy, SourcePolicy>,
    public IndexPolicy
{
public:
    typedef CachingPolicy<FormatPolicy, SourcePolicy> Cache;
    typedef FormatPolicy Format;
...

    inline Vertex getVertex(const typename IndexPolicy::Index& i) {
        return Vertex(
            IndexPolicy::getVertexX(i),
            FormatPolicy::getElevation(Cache::requestItem(IndexPolicy::toLinear(i))),
            IndexPolicy::getVertexZ(i)
        );

gebruikt om multi-gigabyte grids uit te lezen, met compile-time plugable cache, formaat (ie. 32bit float, 16bit float, rgb, raw16, etc), source (netwerk, mpi, stream, etc) en indexing (cartesian, z-curve, etc) en het mooiste is de uiteindelijk code die zonder snelheids verlies is.

[ Voor 21% gewijzigd door Zoijar op 24-03-2004 23:29 ]

[epic007]

Niet fraai, maar wel komisch is dat deze constructie in c++ mogelijk is

C++:

char d = 3["abcde"]; // d is nu 'd'

[Juup]

Tja en deze vind ik nou geweldig:

Perl:

my $number = 16;
if ((1 x $number) =~ m/^(11+)(\1)+$/)
{
  print "$number is not a prime\n";
}

Ik weet helaas niet wie de auteur is. Dit dingetje laat de kracht van regular expressions zien.

[jlrensen]

(helaas) niet zelf geschreven, maar wel erg handig voor het debuggen van php code:

PHP:

function dump_array($var)
{
    switch (gettype($var)) {
    case 'integer':
    case 'double':
    case 'string':
        echo $var;
        break;
    case 'array':
        echo '<table border="1">' . "\n";
        do {
            echo '<TR><TD>';
            echo key($var);
            echo '</TD><TD>';
            dump_array($var[key($var)]);
            echo '</TD></TR>';
           } while (next($var));
        echo '</TABLE>';
        break;
    default:
        echo 'unknown data type';
        break;
    }
}

maakt een tabel van (meerdimensionale) array's

[Grijze Vos]

Hoe meer ik jullie voorbeeldjes fraaie code zie hoe meer ik mijn docenten gelijk ga geven als ze zeggen dat bijvoorbeeld Peterson's algoritme briljant is.

(In dit geval gaat het om docent R.R. Hoogerwoord aan de TU/e.)

[Verwijderd]

Hier een class die de sessions in de DB opslaat, deze class heb ik niet helemaal zelf gemaakt, maar is voor z'n 80% aangepast door mij

PHP:

<?php
  class session {
    var $resource;
    function session($options) {
      $this->error                           = (bool)false;
      $this->sh_sid                          = (bool)false;
      $this->db['host']                      = "DB-Server";
      $this->db['user']                      = "DB-User";
      $this->db['pass']                      = "DB-Password";
      $this->db['dbas']                      = "DB-Database";
      $this->sess['expire']                  = 20;
      $this->sess['name']                    = "sessionid";
      $this->sess['cookies']                 = true;
      $this->sess['only_cookies']            = false;
      $this->sess['probability']             = 100;
      $this->sess['sid_len']                 = false;
      $this->set_ini();
      session_set_save_handler(array(&$this, 'open'), array(&$this, 'close'), array(&$this, 'read'), array(&$this, 'write'), array(&$this, 'destroy'), array(&$this, 'gc'));
      if ((!isset($_REQUEST[$this->sess['name']])) && ($this->sh_sid)) {
        session_id($this->new_sid());
        session_start();
      } else {
        session_start();
      }
    }

    /***************************************************
    Functie voor het instellen van de INI settings
    ***************************************************/
    function set_ini() {
      ini_set('session.save_handler', 'user');
      ini_set('session.name', $this->sess['name']);
      ini_set('session.use_cookies', $this->sess['cookies']);
      ini_set('session.gc_maxlifetime', $this->sess['expire']);
      ini_set('session.gc_probability', $this->sess['probability']);
      ini_set('session.use_only_cookies', $this->sess['only_cookies']);     
    }

    /***************************************************
    Functie voor het openen van de database connectie
    ***************************************************/
    function open($a, $b) {
      $this->resource = @mysql_connect($this->db['host'], $this->db['user'], $this->db['pass']) or $this->error .= mysql_error();
      @mysql_select_db($this->db['dbas']) or $this->error .= 'Could Not Select DB';
      return( $this->error );
    }

    /****************************************************
    Functie die de database connectie sluit
    ****************************************************/
    function close() {
      return ((bool)true);
    }

    /****************************************************
    Functie die data leest van de huidige sessie
    ****************************************************/
    function read($id) {
      $query = @mysql_query("SELECT * FROM `sessions` WHERE `session_id`='$id' AND `session_expire`>".time());
      if (@mysql_num_rows($query) > (int)0) {
        $info = @mysql_fetch_assoc($query);
        return($info['session_data']);
      } else {
        return((bool)false);
      }
    }
    
    /****************************************************
    Functie die data naar de huidige sessie schrijft
    ****************************************************/
    function write($id, $data) {
      $expires = time() + ($this->sess['expire'] * 60);
      $_q = "SELECT `session_id` FROM `sessions` WHERE `session_id`='".session_id()."'";
      $result = @mysql_query($_q, $this->resource);
      if (!@mysql_num_rows($result)) {
        $query = "INSERT INTO `sessions` (`session_id`, `session_expire`, `session_data`) VALUES ('$id', '$expires', '$data')";
      } else {
        $query = "UPDATE `sessions` SET `session_expire`='$expires', `session_data`='$data' WHERE `session_id`='$id' AND `session_expire`>".time();
      }
      return(@mysql_query($query, $this->resource));
    }
    
    /****************************************************
    Functie die de huidige sessie verwijderd
    ****************************************************/
    function destroy($id) {
      $query = "DELETE FROM `sessions` WHERE `session_id`='$id'";
      if (isset($_COOKIE[$this->sess['name']])) {
        unset($_COOKIE[$this->sess['name']]);
      }
      return(@mysql_query($query, $this->resource));
    }

    /****************************************************
    Functie die verlopen sessies verwijderd
    ****************************************************/
    function gc($a) {
      $query = "DELETE FROM `sessions` WHERE `session_expire`<".time();
      return(@mysql_query($query, $this->resource));
    }

    /****************************************************
    Functie om een Error af te handelen (Koppeling naar een error Class)
    ****************************************************/
    function connection_error() {
      return($this->error);
    }

    /****************************************************
    Functie die een nieuwe sessie id genereerd
    ****************************************************/
    function new_sid() {
      $_sid  = (bool)false;
      $chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
      $count = (int)strlen($chars);
      for($i = (int)0; $i < $this->sess['sid_len']; $i++ ) {
        $_sid .= $chars[mt_rand((int)0, $count - (int)1)];
      }
      return($_sid);
    }
  }
?>

[Verwijderd]

jlrensen schreef op 26 maart 2004 @ 00:54:
(helaas) niet zelf geschreven, maar wel erg handig voor het debuggen van php code:

PHP:

function dump_array($var)
{
    switch (gettype($var)) {
    case 'integer':
    case 'double':
    case 'string':
        echo $var;
        break;
    case 'array':
        echo '<table border="1">' . "\n";
        do {
            echo '<TR><TD>';
            echo key($var);
            echo '</TD><TD>';
            dump_array($var[key($var)]);
            echo '</TD></TR>';
           } while (next($var));
        echo '</TABLE>';
        break;
    default:
        echo 'unknown data type';
        break;
    }
}

maakt een tabel van (meerdimensionale) array's

Ooit gehoord van de functie print_r($array); in php?

[dingstje]

... Of de functie var_dump, als je ook het datatype enzo wilt weten?

[riotrick]

De source van ilse.nl is ook best grappig:

code:

<pre>
#!/usr/bin/perl
eval eval '"'.
          ('['
        ^'+').(      ('[')^
        (')')).(     ('`')|
         ')').(      ('`')|
                     '.').(
                     ('[')^              '/'                 ).+
         '\\'.+      "\"".(         '`'^'!').('`'        ^',').('`'^
         ',').(      ('{')^        '[').('{'^'"')      .('`'^'/').('{'
         ^'.').      ("\{"^       "\)").(      ((     "\{"))^    '[').(
         ('{')^      '(').(       '`'^'%'             ).('`'     ^'!').
         ("\{"^      ')').(       '`'^('#')).(       '`'^'('     ).('{'^
         '[').(      ('`')^        '!').('{'^')')    .('`'^'%').('{'^'['
         ).('`'      ^'"').          ('`'^('%')).(   '`'^',').('`'^'/').
         ("\`"^      '.').(                '`'^"'")   .('{'^
         '[').(      ('{')^        (        '/')).(   ('`')^
         '/').(      '{'^'['      ).('{'   ^'.').(     '{'^'('    ).((
         '\\'))      .('\\').(   '`'|'.').('\\').       '"'.';'.(('!')^
         "\+").       "\"";$:=      '.'^'~';$~=           '@'|'(';#;#
__END__
</pre>

Als je het uitvoert krijg je het volgende:

code:

$ lynx -source www.ilse.nl|perl -x
ALL YOUR SEARCH ARE BELONG TO US

[Verwijderd]

*is trots op zijn simpele AI functie *

Nadeel/voordeel ervan is dat elke stap opnieuw de volgende actie bepaald wordt. Binnenkort ook maar ns proberen of het werken met een plan beter werkt .

PHP:

    /* calcNextMove: this function contains the AI of a robot */
    function calcNextMove ($robots, $mykey, $ball) {
      global $input, $drawingarea;
      
      list($trajectory, $time) = $this->extrapolateBallTrajectory();
      list($robot_x, $robot_y, $robot_angle, $robot_speed) = $input->getRobotPosition($mykey);
      
      list($goto_x, $goto_y) = $input->getBallPosition();
      
      /* Loop through predicted locations of ball */
      foreach ($trajectory as $balllocation) {
        /* Now, compare the (predicted) time for the ball to reach this point to the time
           the robot can reach this point */
        $robotmovetime = $this->calculateMoveTime($robot_x, $robot_y, $robot_angle,
                                                  $balllocation[0], $balllocation[1]);

        $robottoolate = ($robotmovetime > $balllocation[4]);
        
        if ($robottoolate != $prevrobottoolate && $prevrobottoolate) {
          $goto_x = $balllocation[0];
          $goto_y = $balllocation[1];
          $time = $robotmovetime;
          break;
        }
        
        $prevrobottoolate = $robottoolate;
      }
      
      echo "AI: ($goto_x, $goto_y), hit in " . round($time * 1000) / 1000 . " seconds\n";
      
      $this->drawHittingPoint($drawingarea, $goto_x, $goto_y);
      
      /* Calculate shortest route */
      if ($goto_x >= $robot_x && $goto_y < $robot_y)
        $required_angle = rad2deg(atan(($goto_x - $robot_x) / ($robot_y - $goto_y)));
      if ($goto_x > $robot_x && $goto_y >= $robot_y)
        $required_angle = rad2deg(atan(($goto_y - $robot_y) / ($goto_x - $robot_x))) + 90;
      if ($goto_x <= $robot_x && $goto_y > $robot_y)
        $required_angle = rad2deg(atan(($robot_x - $goto_x) / ($goto_y - $robot_y))) + 180;
      if ($goto_x < $robot_x && $goto_y <= $robot_y)
        $required_angle = rad2deg(atan(($robot_y - $goto_y) / ($robot_x - $goto_x))) + 270;
      
      $diff_angle = $required_angle - $robot_angle;
      
      if (abs($diff_angle) < 30) { /* We're about right, proceed with moving */
        $this->goForward($mykey);
      } elseif (abs($diff_angle > 180)) { /* Turn the other way! */
        $this->goRotateRight($mykey);
      } else {
        $this->goRotateLeft($mykey);
      }
      
    }

[ Voor 4% gewijzigd door Verwijderd op 22-07-2004 11:41 ]

[Verwijderd]

Verwijderd schreef op 22 juli 2004 @ 08:50:
Hier een class die de sessions in de DB opslaat, deze class heb ik niet helemaal zelf gemaakt, maar is voor z'n 80% aangepast door mij

PHP:

...
    /*************************************************** 
    Functie voor het openen van de database connectie 
    ***************************************************/ 
    function open($a, $b) { 
      $this->resource = @mysql_connect($this->db['host'], $this->db['user'], 
             $this->db['pass']) or $this->error .= mysql_error(); 
      @mysql_select_db($this->db['dbas']) or $this->error .= 'Could Not Select DB'; 
      return( $this->error ); 
    }
...

Dit topic gaat over fraaiste prog. voorbeelden. Iedereen zit zichzelf hier een schouderklopje te geven, maar niemand zegt wat hij/zij nou fraaie code vindt.
Wat ik bijvoorbeeld zeer slecht vind aan de code hierboven, is dat het commentaar letterlijk nergens voor nodig is. Je moet alleen commentaar zetten bij dingen die onduidelijk kunnen zijn of waarvan je vermoedt dat je er later niets meer van snapt. We zijn allemaal programmeur, en we zien echt wel dat bij een functie open in een database class, dat daar een connectie gemaakt wordt. Hoeft niet becommentarieerd te worden.

Als ik mezelf dan toch op de schouders mag kloppen:

Java:

// Copyright 2004 NextAvenue. All rights reserved.
//-----------------------------------------------------
//
// class.xml.js
//
// This file contains the XML class for NextAvenue. The class itself is portable, it
// runs on its own and has no dependancies.
//
// class name: XML
// properties: - onload => the function that should be fired after
//                         loading the XML file
// methods:    - load ( string sFile )
//
//               The function loads the XML file, and fires the onload function. The
//               onload parameter must be set before calling this function.
//
//             - getElementsByTagName ( string sTagNames, node StartNode )
//
//               The function gets all tags that match the sTagNames pattern. Example:
//               books/book/title, to get all titles from all books.
//               If StartNode is set to NULL or omitted the function starts parsing from
//               the most upper node. If StartNode is set, the function starts from that
//               node.
//
//             - getNodeValue ( node Node )
//               Gets the value of a node, if the childLength is 1 and the childNode is a
//               textnode return the text. If the childLength > 1 but some childNode is
//               CDATA node return the value of that node. Else the function returns NULL
//
//  @author Jorgen Horstink - www.nextavenue.com
//
function XML() {

  this.doc = null;
  this.onload = null;

  this.load = function (sFile) {
    /**
     * If one tries to load an unexisting xml file, it's clear that loading will fail.
     * IE does not throws an exception, but Gecko does. That's why this try-catch
     * statement is for.
     */
    try {
      if (sFile) {
        if (window.ActiveXObject){
          this.doc = new ActiveXObject("Microsoft.XMLDOM");
        } else if (document.implementation && document.implementation.createDocument) {
          this.doc = document.implementation.createDocument("","",null);
        }
        if (typeof this.doc != "undefined") {
          this.doc.async=false;
          this.doc.load(sFile);
          /**
           * This is for IE only. I do not need to check the browser, because Mozilla
           * has already thrown an exception. So if the root element had no childnodes
           * you can be pretty sure the file does not exist.
           *
           * N.B. It is also possible the user tried to load an empty document!!!
           */
          if (!this.doc.hasChildNodes()) {
            return (false);
          }
          if (typeof this.onload == "function") {
            this.onload();
          }
        }

        return (this.doc);
      }
    } catch (e) {
      /**
       * On every throw by the browser: return false. Something went seriously wrong so
       * returning false is the only right thing to do. Gecko throws an exception when
       * the filename does not exist.
       */
      return (false);
    }
  }

  
  this.getElementsByTagName = function (sTagNames, nStartNode) {
    var hasStartNode = true;
    if (nStartNode == null) {
      hasStartNode = false;
      nStartNode = this.doc;
    }
    var a = (sTagNames + "").split("/");
    var aPossibleMatches = new Array();
    /**
     * This is important. If no startnode is set, it is possible the
     * document node has multiple childNodes. If one sets the startnode,
     * there is only on node to start with...
     */
    if (hasStartNode) {
      aPossibleMatches[0] = new Array();
      aPossibleMatches[0][0] = nStartNode;
    } else {
      aPossibleMatches[0] = nStartNode.childNodes;
    }

    for (var i = 1; i < a.length; i++) {
      aPossibleMatches[i] = new Array();
      for (var j = 0; j < aPossibleMatches[i-1].length; j++) {
        for (var k = 0; k < aPossibleMatches[i-1][j].childNodes.length; k++) {
          var oItem = aPossibleMatches[i-1][j].childNodes[k];
          if (oItem.nodeName == a[i]) {
            aPossibleMatches[i].push(oItem);
          }
        }
      }
    }
    return (aPossibleMatches[a.length-1].length == 0 ? false : aPossibleMatches[a.length-1]);
  }

  /**
   * Gets the value of a give node
   *
   * @param   element nNode
   * @return  null | the value of the node
   *
   * The function walks through all childnodes of the given node. If the nodeType is 3, it
   * means a TEXT_NODE has been found. The first TEXT_NODE that has been found, may be returned
   * or not. That depends on whether or not a CDATA_NODE will be found. The value of a CDATA
   * node has a higher priority...
   *
   * I.E.
   *
   * <foo>
   *   bar
   * </foo>
   *
   * There is only one childNode of the type: TEXT_NODE, so that value will be returned
   *
   * <foo>
   *   <![CDATA[
   *     bar
   *   ]]>
   * </foo>
   *
   * In Gecko there are three childNodes. The first childNode is a TEXT_NODE with value "    "
   * some whitespace. A TEXT_NODE is found, so this value may be returned. But wait, the second
   * node is a CDATA node. The CDATA node has a higher priority, so the value of the CDATA node
   * (the first CDATA node) will be returned: the value 'bar'
   */
  this.getNodeValue = function (nNode) {
    var sRet = null;
    for (var i = 0; i < nNode.childNodes.length; i++) {
      switch (nNode.childNodes[i].nodeType) {
        case 3:
          if (sRet == null) {
            sRet = nNode.childNodes[i].nodeValue;
          }
          break;
        case 4:
          return (nNode.childNodes[i].nodeValue);
      }
    }
    return (sRet);
  }
}

Deze simpele kleine XML class is voor zover ik kan zien netjes becommentarieerd. Goed commentaar zie ik als nette code. Dat niet alleen, maar wel één van de vereisten. Logische variabelname zijn ook een must en verder ben ik fan van hongaarse notatie of een variant daarop; aangeven met een letter wat het datatype van de variabele is.

[ Voor 12% gewijzigd door Verwijderd op 22-07-2004 13:09 ]

[Creepy]

Verwijderd schreef op 22 juli 2004 @ 11:45:

Deze simpele kleine XML class is voor zover ik kan zien netjes becommentarieerd. Goed commentaar zie ik als nette code. Dat niet alleen, maar wel één van de vereisten. Logische variabelname zijn ook een must en verder ben ik fan van hongaarse notatie of een variant daarop; aangeven met een letter wat het datatype van de variabele is.

Commentaar is 1 ding, maar halve verhalen gaat mij iets te ver ("but wait, bla bla bla")
En je commentaar is incompleet. Je meld dat er 3 nodes zijn in Gecko en je beschrijft er maar twee

code:

this.getNodeValue = function (nNode) { 
    var sRet = null; 
    for (var i = 0; i < nNode.childNodes.length; i++) { 
      switch (nNode.childNodes[i].nodeType) { 
        case 3: 
          if (sRet == null) { 
            sTempRet = nNode.childNodes[i].nodeValue; 
          } 
          break; 
        case 4: 
          return (nNode.childNodes[i].nodeValue); 
      } 
    } 
    return (sRet); 
  }

Leuk dat commentaar in je code. Maar wat is case3 ? Wat is case 4? Magic number zijn naar mijn idee nou niet echt een voorbeeld van fraaie code, had er dan in elk geval constanten of een enumeratie van gemaakt.

En waarom vul je de variabele sTempRet en doe je er vervolgens niks meer mee?

[ Voor 10% gewijzigd door Creepy op 22-07-2004 12:54 ]

[Verwijderd]

Creepy schreef op 22 juli 2004 @ 12:50:
[...]

Commentaar is 1 ding, maar halve verhalen gaat mij iets te ver ("but wait, bla bla bla")
En je commentaar is incompleet. Je meld dat er 3 nodes zijn in Gecko en je beschrijft er maar twee

code:

this.getNodeValue = function (nNode) { 
    var sRet = null; 
    for (var i = 0; i < nNode.childNodes.length; i++) { 
      switch (nNode.childNodes[i].nodeType) { 
        case 3: 
          if (sRet == null) { 
            sTempRet = nNode.childNodes[i].nodeValue; 
          } 
          break; 
        case 4: 
          return (nNode.childNodes[i].nodeValue); 
      } 
    } 
    return (sRet); 
  }

Leuk dat commentaar in je code. Maar wat is case3 ? Wat is case 4? Magic number zijn naar mijn idee nou niet echt een voorbeeld van fraaie code, had er dan in elk geval constanten of een enumeratie van gemaakt.

En waarom vul je de variabele sTempRet en doe je er vervolgens niks meer mee?

Kijk, nu wordt de discussie zinnig. Ik noem in het commentaar inderdaad drie nodeType, ik noem de eerst en de tweede aangezien de functie ze ook zo bekijkt. Nadat de tweede (een CDATA node) gevonden is, kan de functie al retouneren. Bovendien hoef je niet geniaal te zijn om te zien dat de derde Node ook een TEXT_NODE is.

Die sTempRet was idd nog een foute bij het intikken van het bericht, was vergeten die om te zetten naar sRet.

Case 3 is natuurlijk een nodeType en wel een TEXT_NODE, Case 4 is ook een nodeType en een CDATA_NODE. Voor mij erg logisch en ik denk dat elke programmeur die met DOM werkt die nummers wel uit zijn kop kent. Daarom zet ik er geen commentaar bij. Misschien is gebruik maken van de constanten voor leken wat duidelijker, maar je programmeert niet voor leken. Toch?
Is hier een punt van discussie ontstaan?


Ik ga je gelijk geven, had een discussie NMe84 op MSN en ik dacht opeens aan OpenGL... Zou er niet aan moeten denken dat ik voor al die constanten de nummers zou moet weten...
TEXT_NODE gebruiken i.p.v. 3 is inderdaad veel beschrijvender.


// Edit
Dat stuk commentaar had natuurlijk betrekking op het voorbeeld erboven...

[ Voor 15% gewijzigd door Verwijderd op 22-07-2004 13:29 ]

[RwD]

Verwijderd schreef op 22 juli 2004 @ 11:45:
...

Als ik mezelf dan toch op de schouders mag kloppen:

Java:

...
    /**
     * If one tries to load an unexisting xml file, it's clear that loading will fail.
     * IE does not throws an exception, but Gecko does. That's why this try-catch
     * statement is for.
     */

....

Klop niet te hard, anders is straks al je Engels er uit.

"That's why this try-catch statement is for."

Wat ik bedoel is eigenlijk dat als je commentaar er bij zet, en je doet dit in het Engels, hoeft het eigenlijk alleen maar begrijpbaar te zijn, niet correct. Maar correct (en wellicht zelf proper English) staat wel stukken beter en professioneler, niet dan?

offtopic:
Ikzelf heb in Amerika gewoond, en proper English zit er helaas niet in, maar grammaticaal correct Engels wel...

[BoomSmurf]

Wel, moge het even duidelijk zijn dat ik gestopt ben met Informatica twee jaar geleden omdat het zo godsgruwelijk saai was (op de TU/e) en er een 99% ultranerd mentaliteit hing (dan is Natuurkunde toch boeiender ). Ingewikkelde - of liever, moeilijk en duur verwoorde - dingen zal je van mij dus ook niet horen. En of m'n proc's meer dan 2 niveau's diep zijn zal me al helemaal een worst zijn Ik zal m'n eigen code dus ook niet opdringen als mooi of briljant. Wat ik echter wel een hele slimme was Garbage collection onder Delphi <= 7 dmv interfaces. Bv:

code:

var SL: TStringList;
      O: TObject;
      MijnObject: TMijnClass;
begin
  Garbage.StringList(SL);
  // vereist natuurlijk wel die specifieke procedure

  Garbage.Generic(TStringList, O);
  SL := (O as TStringList);
  // Die minder mooi is en als je em vaker dan één keer gebruikt is het makkelijker 
  // om gewoon die proc te definieren.

  MijnClass.CreateGarbage(MijnObject);

Hoe heel die class werkt ga ik niet posten, is welbekend. Google er maar op of zo. Heb em zelf geschreven (voor de oefening) maar er zijn er meerdere te vinden door ander volk. Mijn eigen classes hebben ook vrijwel allemaal een class method CreateGarbage(...) voor dit doel. Natuurlijk is dit gewoon standaard in een hoop andere talen maar op deze manier is het toch wat meer expliciet.


Verder vindt ik het altijd wel leuk om wat met MMX en SSE aan te kloten, de resultaten mogen er wezen. Het volgende bijvoorbeeld:

(NB deze kan waarschijnlijk nog veel sneller en dat je toch al die info krijgt, maar het hoefde alleen maar veel sneller te zijn dan de pascal versie want daar kon ik ondertussen koffie gaan zetten)

code:

procedure SubImage(DestRGB, Src1, Src2: TBitmap; var SubInfo: TSubInfo);
var
    BaseDestRGB, BaseSrc1, BaseSrc2,
    IncDestRGB, IncSrc1, IncSrc2: Cardinal;
    pDestRGB, pSrc1, pSrc2: PDWORD;
    W, H: Cardinal;

    DiffMin, DiffMax, DiffTotH, DiffTotL: Int64;
    DiffMinC, DiffMaxC: Cardinal;
    DiffTotR, DiffTotG, DiffTotB, DiffTotal: Cardinal;
begin
  BaseDestRGB := Cardinal(DestRGB.Scanline[0]);
  BaseSrc1 := Cardinal(Src1.Scanline[0]);
  BaseSrc2 := Cardinal(Src2.Scanline[0]);

  IncDestRGB := Cardinal(DestRGB.Scanline[1]) - Cardinal(DestRGB.Scanline[0]);
  IncSrc1 := Cardinal(Src1.Scanline[1]) - Cardinal(Src1.Scanline[0]);
  IncSrc2 := Cardinal(Src2.Scanline[1]) - Cardinal(Src2.Scanline[0]);

  W := Src1.Width div 2; { Handle 2 bytes at a time }
  H := Src1.Height;

  DiffMin := $FFFFFFFFFFFFFFFF; { = MM4}
  DiffMax := $0; { = MM5}

  DiffTotH := 0; { = MM6}
  DiffTotL := 0; { = MM7}

asm
{  for i := 0 to DestR.Height - 1 do begin}
  mov ecx, H

  pxor mm3, mm3
  movq mm4, DiffMin
  movq mm5, DiffMax
  movq mm6, DiffTotH
  movq mm7, DiffTotL

@OuterLoop:
      mov eax, BaseDestRGB
      mov pDestRGB, eax

      mov eax, BaseSrc1
      mov pSrc1, eax

      mov eax, BaseSrc2
      mov pSrc2, eax

{    for j := 0 to DestR.Width - 1 do begin}
      mov edx, W

@InnerLoop:
{ RGB := Absolute(PSrc1 - PSrc2) }
        mov eax, PSrc1
        movq mm0, [eax]
        movq mm1, mm0

        mov eax, PSrc2
        movq mm2, [eax]

        pminub mm1, mm2
        pmaxub mm0, mm2

        psubusb mm0, mm1

        mov eax, PDestRGB
        movntq [eax], mm0

{ DiffMin }
        pminub mm4, mm0

{ DiffMax }
        pmaxub mm5, mm0

{ DiffTotal }
{1}
        movq mm1, mm0
        movq mm2, mm0
        psrld mm1, 16

        punpcklbw mm1, mm3
        punpcklwd mm1, mm3
        punpcklbw mm2, mm3
        punpcklwd mm2, mm3

        paddd mm6, mm1
        paddd mm7, mm2
{2}
        movq mm1, mm0
        movq mm2, mm0
        psrlq mm1, 32
        psrlq mm2, 32
        psrld mm1, 16

        punpcklbw mm1, mm3
        punpcklwd mm1, mm3
        punpcklbw mm2, mm3
        punpcklwd mm2, mm3

        paddd mm6, mm1
        paddd mm7, mm2

{ Inc pointers }
        add pDestRGB, 8
        add pSrc1, 8
        add pSrc2, 8

        dec edx
        jnz @InnerLoop
{ end InnerLoop }

{ Inc Pointers }
      mov eax, IncDestRGB
      add BaseDestRGB, eax

      mov eax, IncSrc1
      add BaseSrc1, eax

      mov eax, IncSrc2
      add BaseSrc2, eax

      dec ecx
      jnz @OuterLoop
{ end OuterLoop }

      movq mm0, mm4
      psrlq mm0, 32
      pminub mm4, mm0
      movd DiffMinC, mm4

      movq mm0, mm5
      psrlq mm0, 32
      pmaxub mm5, mm0
      movd DiffMaxC, mm5

      movd DiffTotR, mm6

      movq mm0, mm7
      psrlq mm0, 32
      movd DiffTotG, mm0

      movd DiffTotB, mm7

      emms
  end;

  SubInfo.DiffTotR := DiffTotR;
  SubInfo.DiffTotG := DiffTotG;
  SubInfo.DiffTotB := DiffTotB;

  SubInfo.DiffMinR := (DiffMinC AND $00FF0000) shr 16;
  SubInfo.DiffMinG := (DiffMinC AND $0000FF00) shr 8;
  SubInfo.DiffMinB := (DiffMinC AND $000000FF);

  SubInfo.DiffMaxR := (DiffMaxC AND $00FF0000) shr 16;
  SubInfo.DiffMaxG := (DiffMaxC AND $0000FF00) shr 8;
  SubInfo.DiffMaxB := (DiffMaxC AND $000000FF);

  SubInfo.DiffAvgR := DiffTotR div (W * H * 2);
  SubInfo.DiffAvgG := DiffTotG div (W * H * 2);
  SubInfo.DiffAvgB := DiffTotB div (W * H * 2);

  DiffTotal := DiffTotR + DiffTotG + DiffTotG;
  SubInfo.DiffTotal := DiffTotal;
  SubInfo.DiffAverage := DiffTotal div (W * H * 2 * 3);
end;

Berekend wat zooi aan twee 32bit RGB plaatjes, wat voor de meeste code zorgt. De output zelf maken is het kleinste deel. Was puur om wat te onderzoeken voor mezelf. Heb er ook versies van die bv de standaard deviatie berekenen van de afwijking van de plaatjes. Ik heb ergens ook nog een retesnelle SSE versie van RGB32 naar YUY2 conversie (voor overlay gebruik) maar die kan ik zo snel niet terugvinden. En natuurlijk alphablending support routines, die zijn ook het makkelijkst in MMX / SSE

Allemaal niet zo boeiend dus

[ Voor 5% gewijzigd door BoomSmurf op 22-07-2004 16:28 ]

[Verwijderd]

RwD schreef op 22 juli 2004 @ 14:27:
[...]
Klop niet te hard, anders is straks al je Engels er uit.

"That's why this try-catch statement is for."

Wat ik bedoel is eigenlijk dat als je commentaar er bij zet, en je doet dit in het Engels, hoeft het eigenlijk alleen maar begrijpbaar te zijn, niet correct. Maar correct (en wellicht zelf proper English) staat wel stukken beter en professioneler, niet dan?

offtopic:
Ikzelf heb in Amerika gewoond, en proper English zit er helaas niet in, maar grammaticaal correct Engels wel...

Als we grammaticaal gaan mierenneuken, dan zie ik nog wel 2 fouten in dat stukje tekst van mij. 1.) it's clear that loading will fail -> that is overbodig en mag/moet weggelaten worden 2.) IE does not throws an exception

Punt is dat je beter Engels commentaar kan zetten waar wat fouten in zitten, dan vlekkeloos Nederlands. Tuurlijk staat voutloos beter/professioneler, maar English is nou eenmaal niet mijn natieve taal. Dat ik vouten maak is dus loochies.

Ik snap je punt dus niet helemaal. Foutloos staat beter, maar ik ben niet bij machte om perfect Engels te schrijven.

[Creepy]

Verwijderd schreef op 22 juli 2004 @ 13:02:
[...]
Case 3 is natuurlijk een nodeType en wel een TEXT_NODE, Case 4 is ook een nodeType en een CDATA_NODE. Voor mij erg logisch en ik denk dat elke programmeur die met DOM werkt die nummers wel uit zijn kop kent. Daarom zet ik er geen commentaar bij. Misschien is gebruik maken van de constanten voor leken wat duidelijker, maar je programmeert niet voor leken. Toch?
Is hier een punt van discussie ontstaan?


Ik ga je gelijk geven, had een discussie NMe84 op MSN en ik dacht opeens aan OpenGL... Zou er niet aan moeten denken dat ik voor al die constanten de nummers zou moet weten...
TEXT_NODE gebruiken i.p.v. 3 is inderdaad veel beschrijvender.

En niet te vergeten dat ondanks dat ik met DOM heb gewerkt ik de nummers toch niet ken. In delphi bijv. zijn die nummers niet nodig

[Verwijderd]

Een aantal weken terug was ik bezig mij te verdiepen in xsl-fo (Hiermee kun je onderandere pdf bestanden maken). Tijdens mijn zoektocht op internet kwam in op de volgende pagina:

http://www.renderx.com/chess.html

The power of XSL lies in its ability to perform radical transformations of the XML data source. This page contains yet another proof for this fact: you can build a chessgame viewer with a stylesheet!

The source document is a transcription of a chess game played by Garry Kasparov against a chess supercomputer -- IBM Deep Blue. The game is encoded in a form resembling the well-known Portable Game Notation (PGN) format. The source is very compact: a sample game on this page [DeepBlue.xml] is less than 4 kBytes in size.

The stylesheet converts this arid text into a sequence of board diagrams, drawing every intermediate position as a graphical image (a special chess font is used). Applying a 23 kB stylesheet [chess.xsl], we get a 415 kBytes (!) FO stream [DeepBlue.fo]. These numbers give an idea of how deep the transformation is.

Deze stylesheet geeft duidelijk de kracht van xsl aan. Helaas is dit voor mij nog allemaal iets te moeilijk om zelf te schrijven.

[Verwijderd]

Een van de beste (C++) progsels vind ik toch wel auto_ptr hoor ^^

[PommeFritz]

Helaas geen source of link, maar ik herinner mij het volgende uit de tijd dat ik nog een C=64 hackert was :
Zoals je wellicht weet bevatte de 1541 disk-drive van de c=64 ook een 6502 microprocessor inclusief een hoeveelheid RAM.
Welnu. Waarom zouden we de diskdrive dan niet als 2e computer gebruiken
Zodoende had iemand een fractal-programma gemaakt (notoir traag natuurlijk) dat de ene helft van de fractal op de C=64 zelf uitrekende, en de andere helft tegelijkertijd op de diskdrive

Hatsaa, multiprocessing op zolder, eind jaren 80

[Verwijderd]

PommeFritz schreef op 27 juli 2004 @ 00:18:
Helaas geen source of link, maar ik herinner mij het volgende uit de tijd dat ik nog een C=64 hackert was :
Zoals je wellicht weet bevatte de 1541 disk-drive van de c=64 ook een 6502 microprocessor inclusief een hoeveelheid RAM.

Memories, sweet memories

Het (Disk)OS dat op de 1541 draaide was overigens een stuk interessanter dan dat van de C64 zelf. Omdat er geen controllers in die drive zaten moest de 6502 dus zowel de communicatie met de C64 als het aansturen van de drive hardware regelen en was multitasking nodig. Er draaiden dus twee concurrerende threads die alletwee tijdcritisch waren, als jeugdige hacker is me bij het bestuderen van de (gedisassemblede) source dan ook menig lichtje gaan branden.

Wat ik in die tijd deed was het wiel vaak opnieuw uitvinden en me vervolgens heel slim vinden. Ik heb eens maanden op een compressor zitten schrijven en zo zelfstandig fibonacci coding en wat later shannon-fano coding uitgewerkt. Toen ik tijdens een computerbeurs een geek trof die me uitlegde hoe huffman coding in zijn werk gaat was ik nogal gedesillusioneerd, vooral toen hij vertelde dat het met arithmetische coding nog strakker kan.

Tegenwoordig (na zo'n 25 jaar programmeren) heb ik niet meer het idee dat ik zelf zo geweldig/geniaal ben. Ik heb wel eens een aardig idee waarmee ik enkele malen de big-O verslagen heb, maar ik maak me niet meer wijs dat ik in de zelfde divisie speel als Huffman, Hoare, Knuth, Peterson en consorten.