/**************************************** * Procedure qui stocke une valeur * dans la pyramide. Gere la liste des * places ***************************************/ inline void SetValueAt(int val, int lig, int diag) { /* Variables */ int t,ind; /* S'il y a deja un nombre a cette case, on le retire de la liste des pris */ t = ValueAt(lig, diag); ind = Indice(lig, diag); if((t != 0) && place[t-1] == ind) place[t-1] = OUT_OF_PYR; /* On place l'element dans la pyramide */ elements[ind] = val; /* On le marque comme etant pris */ place[val-1] = ind; /* Maintien de la liste des places */ if(progres < ind+1) progres = ind+1; }
/**************************************** * Renvoie TRUE si val est dans la pyramide * avant la position (lig, diag) ***************************************/ inline int Contains(int val, int lig, int diag) { /* On regarde dans la table si val est place avant * 1 <= val <= nb_elem */ return(place[val-1] <= Indice(lig, diag)); }
/**************************************** * Fonction d'acces a une valeur de la * pyramide (parcours par diagonale) ***************************************/ inline int ValueAt(int lig, int diag) { return elements[Indice(lig, diag)]; }
/** * Devuelve true si y sólo e pertenece al conjunto. * Notar que no es requerido que e pertenezca al rango de c. * Implementa la función PERTENECE?(in c: conjAcotado, in e: nat) -> res : bool * PRE: { true } * POS: { res = e € ConjSuby(c) } * Complejidad: O(1) */ bool ConjAcotado::Pertenece(Nat e) const { return EnRango(e) and pertenencia.Definido(Indice(e)); }
/** * Agrega un elemento al conjunto. * Implementa la función AGREGAR(in/out c: conjAcotado, in e : nat) * PRE: { c = c_0 ^ Infimo(c) <= e <= Supremo(c) } * POS: { c = Ag(e, c_0) } * Complejidad: O(1) */ void ConjAcotado::Agregar(Nat e) { assert(EnRango(e)); if (!Pertenece(e)) { pertenencia.Definir(Indice(e), elementos.AgregarRapido(e)); } }
/** * Elimina a de c, si es que estaba. * Observar que no es requerido que e pertenezca al rango de c. * Implementa la función ELIMINAR(in/out c: conjAcotado, in e: nat) * PRE: { c = c_0 } * POS: { ConjSuby(c) = ConjSuby(c_0) \ {e} ^ Rango(c) = Rango(c_0) } * Complejidad: O(1) */ void ConjAcotado::Eliminar(Nat e) { if (EnRango(e) && Pertenece(e)) { pertenencia[Indice(e)].EliminarSiguiente(); pertenencia.Borrar(Indice(e)); } }
/* ** Noise function, returning the Perlin Noise at a given point */ float Noise (const float x, const float y, const float z, const float t) { /* The unit hypercube containing the point */ const int x1 = (int) (x > 0 ? x : x - 1); const int y1 = (int) (y > 0 ? y : y - 1); const int z1 = (int) (z > 0 ? z : z - 1); const int t1 = (int) (t > 0 ? t : t - 1); const int x2 = x1 + 1; const int y2 = y1 + 1; const int z2 = z1 + 1; const int t2 = t1 + 1; /* The 16 corresponding gradients */ const char * g0000 = gradient[Indice (x1, y1, z1, t1)]; const char * g0001 = gradient[Indice (x1, y1, z1, t2)]; const char * g0010 = gradient[Indice (x1, y1, z2, t1)]; const char * g0011 = gradient[Indice (x1, y1, z2, t2)]; const char * g0100 = gradient[Indice (x1, y2, z1, t1)]; const char * g0101 = gradient[Indice (x1, y2, z1, t2)]; const char * g0110 = gradient[Indice (x1, y2, z2, t1)]; const char * g0111 = gradient[Indice (x1, y2, z2, t2)]; const char * g1000 = gradient[Indice (x2, y1, z1, t1)]; const char * g1001 = gradient[Indice (x2, y1, z1, t2)]; const char * g1010 = gradient[Indice (x2, y1, z2, t1)]; const char * g1011 = gradient[Indice (x2, y1, z2, t2)]; const char * g1100 = gradient[Indice (x2, y2, z1, t1)]; const char * g1101 = gradient[Indice (x2, y2, z1, t2)]; const char * g1110 = gradient[Indice (x2, y2, z2, t1)]; const char * g1111 = gradient[Indice (x2, y2, z2, t2)]; /* The 16 vectors */ const float dx1 = x - x1; const float dx2 = x - x2; const float dy1 = y - y1; const float dy2 = y - y2; const float dz1 = z - z1; const float dz2 = z - z2; const float dt1 = t - t1; const float dt2 = t - t2; /* The 16 dot products */ const float b0000 = Dot_prod(dx1, g0000[0], dy1, g0000[1], dz1, g0000[2], dt1, g0000[3]); const float b0001 = Dot_prod(dx1, g0001[0], dy1, g0001[1], dz1, g0001[2], dt2, g0001[3]); const float b0010 = Dot_prod(dx1, g0010[0], dy1, g0010[1], dz2, g0010[2], dt1, g0010[3]); const float b0011 = Dot_prod(dx1, g0011[0], dy1, g0011[1], dz2, g0011[2], dt2, g0011[3]); const float b0100 = Dot_prod(dx1, g0100[0], dy2, g0100[1], dz1, g0100[2], dt1, g0100[3]); const float b0101 = Dot_prod(dx1, g0101[0], dy2, g0101[1], dz1, g0101[2], dt2, g0101[3]); const float b0110 = Dot_prod(dx1, g0110[0], dy2, g0110[1], dz2, g0110[2], dt1, g0110[3]); const float b0111 = Dot_prod(dx1, g0111[0], dy2, g0111[1], dz2, g0111[2], dt2, g0111[3]); const float b1000 = Dot_prod(dx2, g1000[0], dy1, g1000[1], dz1, g1000[2], dt1, g1000[3]); const float b1001 = Dot_prod(dx2, g1001[0], dy1, g1001[1], dz1, g1001[2], dt2, g1001[3]); const float b1010 = Dot_prod(dx2, g1010[0], dy1, g1010[1], dz2, g1010[2], dt1, g1010[3]); const float b1011 = Dot_prod(dx2, g1011[0], dy1, g1011[1], dz2, g1011[2], dt2, g1011[3]); const float b1100 = Dot_prod(dx2, g1100[0], dy2, g1100[1], dz1, g1100[2], dt1, g1100[3]); const float b1101 = Dot_prod(dx2, g1101[0], dy2, g1101[1], dz1, g1101[2], dt2, g1101[3]); const float b1110 = Dot_prod(dx2, g1110[0], dy2, g1110[1], dz2, g1110[2], dt1, g1110[3]); const float b1111 = Dot_prod(dx2, g1111[0], dy2, g1111[1], dz2, g1111[2], dt2, g1111[3]); /* Then the interpolations, down to the result */ const float idx1 = Spline5 (dx1); const float idy1 = Spline5 (dy1); const float idz1 = Spline5 (dz1); const float idt1 = Spline5 (dt1); const float b111 = Linear (b1110, b1111, idt1); const float b110 = Linear (b1100, b1101, idt1); const float b101 = Linear (b1010, b1011, idt1); const float b100 = Linear (b1000, b1001, idt1); const float b011 = Linear (b0110, b0111, idt1); const float b010 = Linear (b0100, b0101, idt1); const float b001 = Linear (b0010, b0011, idt1); const float b000 = Linear (b0000, b0001, idt1); const float b11 = Linear (b110, b111, idz1); const float b10 = Linear (b100, b101, idz1); const float b01 = Linear (b010, b011, idz1); const float b00 = Linear (b000, b001, idz1); const float b1 = Linear (b10, b11, idy1); const float b0 = Linear (b00, b01, idy1); return Linear (b0, b1, idx1); }