elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Únete al Grupo Steam elhacker.NET


  Mostrar Temas
Páginas: 1 2 3 [4] 5 6 7 8 9 10 11 12 13 14
31  Programación / Programación C/C++ / [duda] implementando la clase reverse_iterator en: 17 Junio 2011, 10:11 am
.
Estoy probando las plantillas que trae la STL y me viene a la mente usar la clase reverse_iterator.

La cuestión es como la uso, hasta ahora solo hice una cutre pero sin usar la plantilla reverse_iterator?

Código
  1.  
  2. #ifndef cbyte_H
  3. #define cbyte_H
  4.  
  5. #include <string.h>
  6. #include <iterator>
  7.  
  8. using namespace std;
  9.  
  10. #ifndef _BYTE_
  11. #define _BYTE_
  12. typedef unsigned char   byte;
  13. #endif  //#ifndef _BYTE_
  14.  
  15. class bytesiterator : public iterator<input_iterator_tag, byte> {
  16.    private:
  17.        const byte            *__p_vbyte;
  18.    public:
  19.        bytesiterator ( const byte *__pv_byte ) : __p_vbyte(__pv_byte) {  };
  20.        virtual ~bytesiterator() {};
  21.        bytesiterator   &operator++() {++this->__p_vbyte;return *this;}
  22.        bytesiterator   operator++(int) {bytesiterator tmp(*this); operator++(); return tmp;}
  23.        bytesiterator   &operator--() {--this->__p_vbyte;return *this;}
  24.        bytesiterator   operator--(int) {bytesiterator tmp(*this); operator--(); return tmp;}
  25.        bool operator   ==(const bytesiterator &__r_cbyte) {return this->__p_vbyte==__r_cbyte.__p_vbyte;}
  26.        bool operator   !=(const bytesiterator &__r_cbyte) {return this->__p_vbyte!=__r_cbyte.__p_vbyte;}
  27.        int operator    *() {return *this->__p_vbyte;}
  28. };
  29.  
  30. class bytesiteratorreverse : public iterator<input_iterator_tag, byte> {
  31.    private:
  32.        const byte            *__p_vbyte;
  33.    public:
  34.        bytesiteratorreverse ( const byte *__pv_byte ) : __p_vbyte(__pv_byte) {  };
  35.        virtual ~bytesiteratorreverse() {};
  36.        bytesiteratorreverse   &operator++() {--this->__p_vbyte;return *this;}
  37.        bytesiteratorreverse   operator++(int) {bytesiteratorreverse tmp(*this); operator++(); return tmp;}
  38.  
  39.        bytesiteratorreverse   &operator--() {++this->__p_vbyte;return *this;}
  40.        bytesiteratorreverse   operator--(int) {bytesiteratorreverse tmp(*this); operator--(); return tmp;}
  41.  
  42.        bool operator   ==(const bytesiteratorreverse &__r_cbyte) {return this->__p_vbyte==__r_cbyte.__p_vbyte;}
  43.        bool operator   !=(const bytesiteratorreverse &__r_cbyte) {return this->__p_vbyte!=__r_cbyte.__p_vbyte;}
  44.        int operator    *() {return *this->__p_vbyte;}
  45. };
  46.  
  47. #ifndef _bytecontainer_
  48. #define _bytecontainer_
  49.  
  50.  
  51. class bytes {
  52.    protected:
  53.        byte        *__p_vbytes;
  54.        size_t      _ln;
  55.  
  56.    public:
  57.        typedef bytesiterator               iterator;
  58.        typedef bytesiteratorreverse        reverse_iterator;
  59.  
  60.        bytes ( const byte* __p_vbytes , size_t _ln) {
  61.            this->__p_vbytes    = new byte[_ln];
  62.            this->_ln           = _ln;
  63.            memcpy( this->__p_vbytes , __p_vbytes , _ln );
  64.        }
  65.        bytes ( ) {
  66.            this->__p_vbytes    = NULL;
  67.            this->_ln           = 0;
  68.        }
  69.        bytes ( size_t _ln ) {
  70.            this->__p_vbytes    = new byte[_ln];
  71.            this->_ln           = _ln;
  72.            memset( this->__p_vbytes , 0 , _ln );
  73.        }
  74.        virtual ~bytes () { delete[] this->__p_vbytes; }
  75.  
  76.        size_t  leght() { return this->_ln; }
  77.        byte*   __p()   { return this->__p_vbytes; }
  78.        void clear()    { if ( this->__p_vbytes ) delete[] this->__p_vbytes; this->_ln = 0; }
  79.  
  80.        iterator begin() {
  81.            //bytesiterator _v_tmp( (const byte*)this->__p_vbytes );
  82.            iterator _v_tmp( (const byte*)this->__p_vbytes );
  83.            return _v_tmp;
  84.        }
  85.  
  86.        iterator end() {
  87.            //bytesiterator _v_tmp( (const byte*)(&this->__p_vbytes[this->_ln]) );
  88.            iterator _v_tmp( (const byte*)(&this->__p_vbytes[this->_ln]) );
  89.            return _v_tmp;
  90.        }
  91.  
  92.        reverse_iterator rbegin() {
  93.            //reverse_iterator _v_tmp( (const byte*)(&this->__p_vbytes[this->_ln-1]) );
  94.            reverse_iterator _v_tmp( (const byte*)(&this->__p_vbytes[this->_ln-1]) );
  95.            return _v_tmp;
  96.        }
  97.  
  98.        reverse_iterator rend() {
  99.            //reverse_iterator _v_tmp( (const byte*)(this->__p_vbytes-sizeof(byte)) );
  100.            reverse_iterator _v_tmp( (const byte*)(this->__p_vbytes-sizeof(byte)) );
  101.            return _v_tmp;
  102.        }
  103.  
  104.        bytes &operator+=( bytes &__p_cbyte) {
  105.            byte    *__p_vbytes = this->__p_vbytes;
  106.            size_t  _ln         = 0;
  107.            size_t  _pos        = 0;
  108.            if ( __p_cbyte.__p_vbytes!=NULL && __p_cbyte._ln>0 ) {
  109.                if ( this->_ln>0 && this->__p_vbytes!=NULL ) {
  110.                    _ln = this->_ln + __p_cbyte._ln;
  111.                    _pos = this->_ln;
  112.                } else {
  113.                    _ln = __p_cbyte._ln;
  114.                }
  115.                __p_vbytes = new byte[_ln];
  116.                memcpy( &__p_vbytes[_pos] , __p_cbyte.__p_vbytes , __p_cbyte._ln );
  117.  
  118.                if ( this->__p_vbytes!=NULL && this->_ln>0 ) {
  119.                    memcpy( __p_vbytes , this->__p_vbytes , this->_ln );
  120.                    delete[] this->__p_vbytes;
  121.                }
  122.            }
  123.            this->__p_vbytes    = __p_vbytes;
  124.            this->_ln           = _ln;
  125.            return *this;
  126.        }
  127.  
  128.        bytes &operator=( bytes &__p_cbyte ) {
  129.            byte    *__p_vbytes = NULL;
  130.            if ( this != &__p_cbyte ) {
  131.                this->_ln           = __p_cbyte._ln;
  132.                if ( this->_ln>0 && __p_cbyte.__p_vbytes != NULL ) {
  133.                    __p_vbytes          = new byte[this->_ln];
  134.                    memcpy( __p_vbytes , __p_cbyte.__p_vbytes , this->_ln );
  135.                } else {
  136.                    this->_ln           = 0;
  137.                }
  138.                delete[] this->__p_vbytes;
  139.                this->__p_vbytes = __p_vbytes;
  140.            }
  141.            return *this;
  142.        }
  143.  
  144.        operator byte*() {
  145.            return this->__p_vbytes;
  146.        }
  147.  
  148.        operator size_t() {
  149.            return this->_ln;
  150.        }
  151.  
  152.        operator long int() {
  153.            return (long int)this->_ln;
  154.        }
  155.  
  156.        operator unsigned long int() {
  157.            return (unsigned long int)this->_ln;
  158.        }
  159.  
  160.        bool operator ==( bytes &__pc_byte ) {
  161.            size_t  _szt_pos    = 0;
  162.  
  163.            if ( __pc_byte.__p_vbytes == this->__p_vbytes ) {
  164.                return true;
  165.            }
  166.            if ( (this->_ln == __pc_byte._ln) && (__p_vbytes != NULL) && (this->__p_vbytes!=NULL) ) {
  167.                while ( _szt_pos<this->_ln ) {
  168.                    if ( __pc_byte.__p_vbytes[_szt_pos] == this->__p_vbytes[_szt_pos] ) {
  169.                        _szt_pos++;
  170.                    } else {
  171.                        return false;
  172.                    }
  173.                };
  174.                return true;
  175.            }
  176.            return false;
  177.        }
  178. };
  179. #endif  //#ifndef _bytecontainer_
  180.  
  181. #endif // cbyte_H
  182.  
  183.  

P.D.: Revise esta liga http://www.cplusplus.com/reference/std/iterator/reverse_iterator/reverse_iterator/ pero cuando la implemento no me sirve ( con respecto a esta clase ).

Dulces Lunas!¡.
32  Foros Generales / Sugerencias y dudas sobre el Foro / [Sugerencia] Tareas en foros en: 13 Junio 2011, 23:43 pm
.
No estaría mal que pusieran una leyenda debajo de los temas destacados la leyenda "No se hacen tareas" o a la hora de crear un nuevo tema arriba/abajo/izquierda/derecha del campo del cuerpo del tema en esta ultima zona a mi me sobra espacio en la pagina y no estaría mal dicha leyenda o poner las reglas mas destacadas en alguna zona ( reglas que sean aleatorias o que cambien entre ellas. ).

Esto seria para que los moderadores solo lleguen lean y borren sin aviso alguno.

P.D.: la sugerencia se que puede no ser valida con respecto a que existe la sección de reglas del foro pero no estaria mal solo poner dicha leyenda.

Dulces Lunas!¡.
33  Programación / Programación C/C++ / [Duda] Sobrecarga de operadores en: 13 Junio 2011, 09:20 am
Estoy haciendo infinidad de pruebas con estas sobrecargas que me han gustado demasiado a tal grado que veo por que dicen que c es tan potente, pero bueno yendo al punto mi problema surge al momento de sobrecargar el operador "+" y realizo varias sumas de mi clase.

El resultado de la prueba debería de ser:  620 pero me da 20 alguien sabe a que se debe?.

Código
  1.  
  2. class clstest
  3. {
  4.    public:
  5.        clstest();
  6.        virtual ~clstest();
  7.        clstest &operator +( clstest &c1 ) {
  8.            clstest tmp;
  9.            int i = c1;
  10.            tmp = (this->sMsg + i);
  11.            return tmp;
  12.        }
  13.        clstest &operator +( int c1 ) {
  14.            clstest tmp ;
  15.            int a = (this->sMsg + c1);
  16.            tmp = a;
  17.            return tmp;
  18.        }
  19.        clstest &operator = (clstest &c1) {
  20.            if ( this != &c1 ) {
  21.                this->sMsg = c1;
  22.            }
  23.            return *this;
  24.        }
  25.        clstest &operator = (int c1) {
  26.            this->sMsg = c1;
  27.            return *this;
  28.        }
  29.        operator int() {
  30.            return sMsg;
  31.        }
  32.        operator double() {
  33.            return (double)sMsg;
  34.        }
  35.    protected:
  36.    private:
  37.        int sMsg;
  38. };
  39.  
  40. clstest::clstest()
  41. {
  42.    //ctor
  43.    this->sMsg=0;
  44. }
  45.  
  46. clstest::~clstest()
  47. {
  48.    //dtor
  49. }
  50.  
  51. int main()
  52. {
  53.    clstest a;
  54.    a = 45;
  55.    a = a + a + 10;
  56.    a = a + a + 10 + a;
  57.    a = a + a;
  58.    int res = a;
  59.    return 0;
  60. }
  61.  
  62.  

Dulces Lunas!¡.
34  Foros Generales / Foro Libre / Consejos para deteccion en 3D. en: 11 Junio 2011, 11:31 am
.
Estoy realizando un pequeño motor para un juego en C+OpenGL y me veo en la necesidad de crear una técnica viable para detectar las colisiones

Hay alguna manera lógica de detectar colisiones ( con rangos de error para no exigirle al procesador demasiado ) de manera que dichos objetos estén constantemente en movimiento y cambiando de forma, se que lo puedo hacer con la formula para saber la distancia entre dos puntos, pero la verdadera pregunta es como detectar la colisión entre dos masas?.

Mis opciones hasta ahora son:
*Definir el centro de la masa(figura)  (Detección de colisión por círculos) ( me parece viable, aunque definir el centro lo tendria que hacer en tiempo de diseño de las masas, y estos centros tendrían que ser "invisibles" cosa que no me agrada. ).

*Crear una masa "invisible" (Detección de choques por rectángulos) ( Es decir definir tantos rectángulos en lugares X de la masa y definir los centros de estos rectángulos y posteriormente por medio de 3 de sus vértices de un rectángulo (Coordenadas X,Y,Z de los 3 vértices) la una 4 ajena a este rectángulo. ).

Algunas sugerencias o ideas?

P.D.: No meto códigos ya que solo deseo obtener ideas.

Temibles Lunas!¡.
35  Programación / Programación C/C++ / En donde encuentro esta libreria. en: 11 Junio 2011, 04:12 am
.
Alguien sabe de donde descargo esta librería con el Header indicado?, ya que mi Compilador no lo trae en su paquete (es el IDE Code::Blocks con el compilador Predeterminado).

dlfcn.h

Dulces Lunas!¡.
36  Programación / Programación Visual Basic / [Reto] Barrido de Bits. en: 10 Junio 2011, 04:02 am
.
Crear una función que mueva los bit's (Por si se aparece Karkrack, Cobein o similares NO ASM-Inline) a la izquierda o derecha.

(Los Números binarios se leen de izquierda a derecha, quien no tenga idea use la calculadora de windows o investigue en google como determinar el valor en Base 10).

Los ejemplos son considerando {1 Byte = 8 Bits, con el byte de signo.} la función deberá trabajar con (4 Bytes = 32 bit's = Long)

Ejemplo 1:

Se ingresa el numero  45  de desplazan 2 bit's a la izquierda el resultado es 180
es decir en binario:
00101101  {Desplazando 2 bit's Resultado--->} 10110100

Ejemplo 2:

Se ingresa el numero (-128) se desplazan 5 bit's a la izquierda el resultado es: 0
es decir en binario:
10000000 {Desplazando 5 bit's Resultado--->} 00000000

Ejemplo 3:

Se ingresa el numero 1 se desplazan 5 bit's a la izquierda el resultado es: 32
es decir en binario:
00000001 {Desplazando 5 bit's Resultado--->} 00100000

Ejemplo 4:

Se ingresa el numero 1 se desplazan 5 bit's a la derecha el resultado es: 0
es decir en binario:
00000001 {Desplazando 5 bit's Resultado--->} 00000000

Ejemplo 5:

Se ingresa el numero (-2) se desplazan 5 bit's a la derecha el resultado es: -1
es decir en binario:
11111110 {Desplazando 5 bit's Resultado--->} 11111111

Ejemplo 6:

Se ingresa el numero (-1) se desplazan 5 bit's a la derecha el resultado es: -1
es decir en binario:
11111111 {Desplazando 5 bit's Resultado--->} 11111111

Formato de la funcion:

Código
  1.  
  2. Public Function Bits_d(ByVal lVal As Long, Optional lDesplazamiento As Integer) As Long
  3. ' &#160; // &#160;lVal &#160; &#160; &#160; &#160; &#160; &#160; &#160; &#160;Indica el valor ingresado (Base 10).
  4. ' &#160; // &#160;lDesplazamiento &#160; &#160; Indica la longitud de bit's a dezplazar.
  5. ' &#160; // &#160;Bits_d &#160; &#160; &#160; &#160; &#160; &#160; &#160;Retorna el resultado Final (Base 10)
  6. &#160; &#160;...
  7. End Function
  8.  
  9.  


Edito:


Codigo para probar los resultados:

Código
  1.  
  2. Private Sub Form_Load()
  3. Dim lres        As Long
  4.    lres = DebugAndRet(Bits_d(267614144, (-1)))
  5.    lres = DebugAndRet(Bits_d(lres, (-6)))
  6.    lres = DebugAndRet(Bits_d(lres, 2))
  7.    lres = DebugAndRet(Bits_d(lres, 2))
  8.    lres = DebugAndRet(Bits_d(lres, 2))
  9.    lres = DebugAndRet(Bits_d(lres, 2))
  10.    lres = DebugAndRet(Bits_d(lres, (-2)))
  11.    lres = DebugAndRet(Bits_d(lres, (-24)))
  12. End Sub
  13.  
  14. Private Function DebugAndRet(ByVal lVal As Long) As Long
  15.    Debug.Print lVal
  16.    DebugAndRet = lVal
  17. End Function
  18.  
  19.  

Resultados en el Debug:

Código:

 535228288
-105127936
-26281984
-6570496
-1642624
-410656
-1642624
-2147483648


Resultados en Binario:
Pruebas con Test Manual...

Código:

00001111111100110111011111000000  <-- {267614144}  <--- De este binario se parte...
00011111111001101110111110000000  <-- {-01}
11111001101110111110000000000000  <-- {-06}
11111110011011101111100000000000  <-- {+02}
11111111100110111011111000000000  <-- {+02}
11111111111001101110111110000000  <-- {+02}
11111111111110011011101111100000  <-- {+02}
11111111111001101110111110000000  <-- {-02}
10000000000000000000000000000000  <-- {-24} <-- {-2147483648}


Dulces Lunas!¡.
37  Programación / Programación Visual Basic / ASM en VB6 [Respuesta a Myserik] en: 9 Junio 2011, 09:17 am
.
el código lo pongo publico ya que a mas de a uno le interese a la larga, no soy experto en ASM pero bueno.

Código
  1.  
  2. Option Explicit
  3.  
  4. Private Declare Function LoadLibrary Lib "kernel32.dll" Alias "LoadLibraryA" (ByVal lpLibFileName As String) As Long
  5. Private Declare Function GetProcAddress Lib "kernel32.dll" (ByVal hModule As Long, ByVal lpProcName As String) As Long
  6. Private Declare Function CallWindowProc Lib "USER32" Alias "CallWindowProcW" (ByVal lpPrevWndFunc As Long, ByVal hwnd As Long, ByVal msg As Long, ByVal wParam As Long, ByVal lParam As Long) As Long
  7.  
  8. Private Sub form_load()
  9. Dim bASM(0 To 27)           As Byte
  10. Dim i                       As Integer
  11. Dim sMsg                    As String
  12. Dim sTitulo                 As String
  13.  
  14.    sMsg = "Hola Mundo"
  15.    sTitulo = "Titulo de un msgbox"
  16.  
  17.    '   Cada Instruccion pesa {1 Bytes} y el numero de "_" son la cantidad de bytes esperados habitualmente si son 4 es que sea normalmente un puntero, pero eso depende del formato de la instruccion.
  18.    '   Para informacion de los OpCodes:
  19.    '   //  http://ref.x86asm.net/geek.html
  20.    '   PUSH ____
  21.    '   PUSH ____
  22.    '   PUSH ____
  23.    '   PUSH ____
  24.    '   MOV EAX, ____
  25.    '   CALL EAX
  26.    '   RET
  27.    i = 0
  28.    bASM(i) = &H68: i = LongToByte(vbYesNoCancel, bASM(), i + 1)    ' PUSH {vbYesNoCancel}      5 bytes ( 1(&H68) + long(vbYesNoCancel) ).
  29.    bASM(i) = &H68: i = LongToByte(StrPtr(sTitulo), bASM(), i + 1)  ' PUSH {StrPtr(sTitulo)}    5 bytes ( 1(&H68) + long(StrPtr(sTitulo)) )..
  30.    bASM(i) = &H68: i = LongToByte(StrPtr(sMsg), bASM(), i + 1)     ' PUSH {StrPtr(sMsg)}       5 bytes ( 1(&H68) + long(StrPtr(sMsg)) )..
  31.    bASM(i) = &H68: i = LongToByte(&H0, bASM(), i + 1)              ' PUSH {&H0}                5 bytes ( 1(&H68) + long(&H0) )..
  32.  
  33.    ' MOV {EAX},{LongToByte(GetProcAddress(LoadLibrary("user32.dll"), "MessageBoxW")}
  34.    bASM(i) = &HB8: i = LongToByte(GetProcAddress(LoadLibrary("user32.dll"), "MessageBoxW"), bASM(), i + 1) ' 5 bytes
  35.    bASM(i) = &HFF: i = i + 1 ' CALL ___    1 bytes
  36.    bASM(i) = &HD0: i = i + 1 ' EAX         1 bytes
  37.    bASM(i) = &HC3: i = i + 1 ' RET         1 bytes
  38.    MsgBox CallWindowProc(ByVal VarPtr(bASM(0)), 0&, 0&, 0&, 0&)    ' Run ASM
  39. End Sub
  40.  
  41. Private Function LongToByte(ByVal lLong As Long, ByRef bReturn() As Byte, Optional i As Integer = 0) As Long
  42.    bReturn(i) = lLong And &HFF
  43.    bReturn(i + 1) = (lLong And &HFF00&) \ &H100
  44.    bReturn(i + 2) = (lLong And &HFF0000) \ &H10000
  45.    bReturn(i + 3) = (lLong And &HFF000000) \ &H1000000
  46.    LongToByte = i + 4
  47. End Function
  48.  
  49.  

Dulces Lunas!¡.
38  Programación / Programación Visual Basic / Recopilacion de Funciones con operaciones Binarias. en: 5 Junio 2011, 08:07 am
Bueno ya sabemos que las funciones con operaciones binarias son mas rápidas y mas practicas a la hora de ejecutarse.

La intención de este tema es que se creen una sola publicacion donde se pueden encontrar estas funciones de manera amena.

Código
  1.  
  2. '   //  Para valores tipo Long
  3. Private Sub lSwap(ByRef lVal1 As Long, ByRef lVal2 As Long)
  4.    '   //  Intercambia {lVal1} por {lVal2} y {lVal2} a {lVal1} sin variable temporal
  5.    lVal1 = lVal1 Xor lVal2
  6.    lVal2 = lVal2 Xor lVal1
  7.    lVal1 = lVal1 Xor lVal2
  8. End Sub
  9. Private Function lIsNegative(ByRef lVal As Long)
  10.    '   //  Para cualquier valor que lVal pueda tomar.
  11.    '   //  Comprueba si lval es negativo.
  12.    lIsNegative = (lVal And &H80000000)
  13. End Function
  14.  
  15. Private Function iIsNegative(ByRef iVal As Integer) As Boolean
  16.    '   //  Para cualquier valor que iVal pueda tomar.
  17.    '   //  Comprueba si lval es negativo.
  18.    iIsNegative = (iVal And 32768)
  19. End Function
  20.  
  21. Private Sub iSwap(ByRef iVal1 As Integer, ByRef iVal2 As Integer)
  22.    '   //  Intercambia {iVal1} por {iVal2} y {iVal2} a {iVal1} sin variable temporal
  23.    iVal1 = iVal1 Xor iVal2
  24.    iVal2 = iVal2 Xor iVal1
  25.    iVal1 = iVal1 Xor iVal2
  26. End Sub
  27.  
  28. Private Sub bSwap(ByRef iVal1 As byte, ByRef iVal2 As byte)
  29.    '   //  Intercambia {iVal1} por {iVal2} y {iVal2} a {iVal1} sin variable temporal
  30.    iVal1 = iVal1 Xor iVal2
  31.    iVal2 = iVal2 Xor iVal1
  32.    iVal1 = iVal1 Xor iVal2
  33. End Sub
  34.  
  35. Function max(ByVal val1 As Long, ByVal val2 As Long) As Long
  36.    If (val1 > val2) Then
  37.        max = val1
  38.    Else
  39.        max = val2
  40.    End If
  41. End Function
  42.  
  43. Function min(ByVal val1 As Long, ByVal val2 As Long) As Long
  44.    If (val1 > val2) Then
  45.        min = val2
  46.    Else
  47.        min = val1
  48.    End If
  49. End Function
  50.  
  51. Function bSwapBit(ByVal myLong As Long, ByVal bit1 As Byte, ByVal bit2 As Byte) As Long
  52. '   Los bits se CUENTAS DE DERECHA A IZQUIERDA es decir:    31, 30, ... , 3, 2, 1, 0
  53. '   Solo se admite rango 0 al 31.
  54. Dim aux As Long
  55. Dim mask As Long
  56.  
  57.    aux = max(bit1, bit2)
  58.    bit2 = min(bit1, bit2)
  59.    bit1 = aux  '   max
  60.    Debug.Assert (bit1 > 31)    '   No se permiten numero mayores a 32
  61.    Debug.Assert (bit2 < 0)     '   No se permiten valores negativos
  62.    mask = Not ((2 ^ bit1) Or (2 ^ bit2))
  63.    aux = (2 ^ (bit1 - bit2))
  64.    bSwapBit = (myLong And mask) Or _
  65.               (myLong And (2 ^ bit1)) / aux Or _
  66.               (myLong And (2 ^ bit2)) * aux
  67. End Function
  68.  
  69.  

Si alguien se sabe mas y quiere aportarlas están en el lugar indicado.

Temibles Lunas!¡.
39  Programación / Programación Visual Basic / [Src] cRndNumbersNR ( Generar números aleatorios sin repetir [Very-Fast] ) en: 28 Mayo 2011, 10:47 am
.

@Psyke1

Mas que una matriz quedaría precioso en una clase... al rato lo traslado a una clase para aumentar la velocidad de procesamiento, ya que de este modo se le aumenta el peformance ( en relación procesador/tiempo, pero no memoria ) con una clase.


Este código es una mera actualización directa de este otro, se puede decir que es la version 2.0

[source] Números Aleatorio desde X a Y con excepciones.

Vaya solo le falta una opción a mi punto de vista y es meterle una lista de números antes de generar alguno tal cual se le hace en la función solo que ahora seria una propiedad, y podría modificarse en cualquier instante, pero eso se los dejo a ustedes, yo ya hice mi labor.

* El ordenamiento QuickSort se sustituyo por una heuristica mas eficiente.

En un modulo de clase:

cRndNumbersNR.cls

Código
  1.  
  2. '
  3. ' ////////////////////////////////////////////////////////////////
  4. ' // Autor: BlackZeroX ( Ortega Avila Miguel Angel )            //
  5. ' //                                                            //
  6. ' // Web: http://InfrAngeluX.Sytes.Net/                         //
  7. ' //                                                            //
  8. ' // |-> Pueden Distribuir Este Codigo siempre y cuando         //
  9. ' // no se eliminen los creditos originales de este codigo      //
  10. ' // No importando que sea modificado/editado o engrandesido    //
  11. ' // o achicado, si es en base a este codigo                    //
  12. ' ////////////////////////////////////////////////////////////////
  13.  
  14. Option Explicit
  15.  
  16. Private Declare Function VarPtrA Lib "msvbvm60.dll" Alias "VarPtr" (ByRef Ptr() As Any) As Long
  17. Private Declare Sub lCopyMemory Lib "kernel32.dll" Alias "RtlMoveMemory" (ByVal Destination As Long, ByVal Source As Long, ByVal Length As Long)
  18.  
  19. Private Type stRangos
  20.    lValIni         As Long
  21.    lValEnd         As Long
  22. End Type
  23.  
  24. Private lcvalmax    As Long
  25. Private lcvalmin    As Long
  26.  
  27. Private lvcsplit()  As stRangos
  28. Private lacexcep()  As Long
  29.  
  30. Private bChange     As Long
  31.  
  32. Private Sub Swapnumbers(ByRef lvalone As Long, ByRef lvaltwo As Long)
  33. '   //  Intercambia el contenido de las variables.
  34. Dim lvaltmp         As Long
  35.    lvaltmp = lvalone
  36.    lvalone = lvaltwo
  37.    lvaltwo = lvaltmp
  38. End Sub
  39.  
  40. Private Function Fixnumbers(ByRef lvalmin As Long, lvalmax As Long) As Boolean
  41. '   //  Corrige los valores dados.
  42.    If lvalmax < lvalmin Then
  43.        Call Swapnumbers(lvalmin, lvalmax)
  44.        Fixnumbers = True
  45.    End If
  46. End Function
  47.  
  48. Private Function NumRandom(lvalmin As Long, lvalmax As Long) As Long
  49. '   //  Genera un Numero aleatorio de acuerdo a un rango dado.
  50.    Call Fixnumbers(lvalmin, lvalmax)
  51.    Call Randomize
  52.    NumRandom = (lvalmin - lvalmax) * Rnd + lvalmax
  53. End Function
  54.  
  55. Public Sub Reset()
  56. '   //  Reinicia y permite nuevamente generar los números aleatorios desde el principio, si no aplica este al generar todos los numeros, entonces no generara mas números y devolverá únicamente 0..
  57.    Erase lvcsplit()
  58.    Erase lacexcep()
  59.    ReDim lvcsplit(0 To 0)
  60.    lvcsplit(0).lValIni = lcvalmin
  61.    lvcsplit(0).lValEnd = lcvalmax
  62.    bChange = False
  63. End Sub
  64.  
  65. Public Property Get GetMore() As Boolean
  66. '   //  Hay mas ocurrencias? cuando ya no hay se elimina el array de ocurrencias.
  67.    GetMore = Itsarrayini(VarPtrA(lvcsplit)) Or bChange = True
  68. End Property
  69.  
  70. Private Function Itsarrayini(ByVal lpszv As Long, Optional llen As Long = 4) As Boolean
  71. '   //  Obtiene el limite superior de los numeros a generar de manera aleatoria sin repetir.
  72. Dim lpsz                    As Long
  73.    If lpszv <> 0 And llen > 0 Then
  74.        Call lCopyMemory(ByVal VarPtr(lpsz), ByVal lpszv, llen)
  75.        Itsarrayini = Not lpsz = 0
  76.    End If
  77. End Function
  78.  
  79. Private Sub SeparateRange(ByVal lDivVal As Long, ByVal lindex As Long, ByRef vArray() As stRangos)
  80. '   //  Es un proceso para aplicar el dicho "Divide y Venceras", esto aumenta mucho la velocidad para no repetir numeros dentro de un rango dado y generados de manera aleatoria.
  81. '   //  Repeti un poco de codigo lo siento xP...
  82. Dim lu          As Long
  83. Dim lpsz        As Long
  84.  
  85.    If (vArray(lindex).lValIni <= lDivVal And lDivVal <= vArray(lindex).lValEnd) Then
  86.        lu = UBound(vArray)
  87.        lpsz = VarPtr(vArray(lindex))
  88.        If (vArray(lindex).lValIni = lDivVal) Then
  89.            vArray(lindex).lValIni = vArray(lindex).lValIni + 1
  90.            If (vArray(lindex).lValIni > vArray(lindex).lValEnd) Then
  91.                If (lu > 0) Then
  92.                    lCopyMemory lpsz, lpsz + &H8, ((lu - lindex) * &H8)
  93.                    lu = lu - 1
  94.                    ReDim Preserve vArray(0 To lu)
  95.                Else
  96.                    Erase vArray()
  97.                End If
  98.            End If
  99.        ElseIf (vArray(lindex).lValEnd = lDivVal) Then
  100.            vArray(lindex).lValEnd = vArray(lindex).lValEnd - 1
  101.            If (vArray(lindex).lValIni > vArray(lindex).lValEnd) Then
  102.                If (lu > 0) Then
  103.                    lCopyMemory lpsz, lpsz + &H8, ((lu - lindex) * &H8)
  104.                    lu = lu - 1
  105.                    ReDim Preserve vArray(0 To lu)
  106.                Else
  107.                    Erase vArray()
  108.                End If
  109.            End If
  110.        Else
  111.            lu = lu + 1
  112.            ReDim Preserve vArray(0 To lu)
  113.            lpsz = VarPtr(vArray(lindex))
  114.            lCopyMemory lpsz + &H10, (lpsz + &H8), (((lu - 1) - lindex) * &H8)
  115.            vArray(lindex + 1).lValEnd = vArray(lindex).lValEnd
  116.            vArray(lindex + 1).lValIni = (lDivVal + 1)
  117.            vArray(lindex).lValEnd = (lDivVal - 1)
  118.  
  119.        End If
  120.    End If
  121.  
  122. End Sub
  123.  
  124. Public Property Get GetNumRandom() As Long
  125. '   //  Genera un numero aleatorio sin repetir de acuerdo a un rango de valores dados.
  126. Dim lindex          As Long
  127. Dim lu              As Long
  128. Dim lret            As Long
  129.    If (bChange = True) Then
  130.        Call Fixnumbers(lcvalmin, lcvalmax)
  131.        Call Reset
  132.    End If
  133.    If (GetMore = True) Then
  134.        lindex = NumRandom(0, UBound(lvcsplit))
  135.        lret = NumRandom(lvcsplit(lindex).lValIni, lvcsplit(lindex).lValEnd)
  136.        SeparateRange lret, lindex, lvcsplit
  137.        If (Itsarrayini(VarPtrA(lacexcep)) = True) Then
  138.            lu = UBound(lacexcep) + 1
  139.        Else
  140.            lu = 0
  141.        End If
  142.        ReDim Preserve lacexcep(0 To lu)
  143.        lacexcep(lu) = lret
  144.        GetNumRandom = lret
  145.    End If
  146. End Property
  147.  
  148. Public Property Let minval(ByVal ldata As Long)
  149. '   //  Establece el limite inferior de los numeros a generar de manera aleatoria sin repetir.
  150.    lcvalmin = ldata
  151.    bChange = True
  152. End Property
  153.  
  154. Public Property Get minval() As Long
  155. '   //  Obtiene el limite inferior de los numeros a generar de manera aleatoria sin repetir.
  156.    minval = lcvalmin
  157. End Property
  158.  
  159. Public Property Let maxval(ByVal ldata As Long)
  160. '   //  Establece el limite superior de los numeros a generar de manera aleatoria sin repetir.
  161.    lcvalmax = ldata
  162.    bChange = True
  163. End Property
  164.  
  165. Public Property Get maxval() As Long
  166. '   //  Obtiene el limite superior de los numeros a generar de manera aleatoria sin repetir.
  167.    maxval = lcvalmax
  168. End Property
  169.  
  170. Public Property Get GetNumbers() As Long()
  171. '   //  Devueve una coleccion de los numeros generados.
  172.    GetNumbers() = lacexcep()
  173. End Property
  174.  
  175. Public Function RegenerateThis(ByVal lVal As Long) As Boolean
  176. Dim ii              As Long
  177. Dim lub             As Long
  178.    If (lcvalmin <= lVal) And (lcvalmax >= lVal) Then
  179.        If (breglist = True) Then
  180.            If (Itsarrayini(VarPtrA(lacexcep)) = True) Then
  181.                For ii = 0 To UBound(lacexcep)
  182.                    If (lacexcep(ii) = lVal) Then
  183.                        RemoveInArrayLong ii, lacexcep()
  184.                        Exit For
  185.                    End If
  186.                Next ii
  187.            End If
  188.        End If
  189.        If (Itsarrayini(VarPtrA(lvcsplit)) = True) Then
  190.            lub = UBound(lvcsplit)
  191.            For ii = 0 To (lub - 1)
  192.                If (lvcsplit(ii).lValEnd > lVal) And (lvcsplit(ii + 1).lValIni < lVal) Then
  193.                    If ((lvcsplit(ii).lValEnd + 1) = lVal) Then
  194.                        lvcsplit(ii).lValEnd = lVal
  195.                    ElseIf ((lvcsplit(ii + 1).lValIni) = lVal) Then
  196.                        lvcsplit(ii + 1).lValIni = lVal
  197.                    End If
  198.                    Select Case (lvcsplit(ii).lValEnd = lvcsplit(ii + 1).lValIni)
  199.                        Case 0, 1
  200.                            lub = (lub - 1)
  201.                            lvcsplit(ii).lValEnd = lvcsplit(ii + 1).lValEnd
  202.                            ReDim Preserve lvcsplit(0 To lub)
  203.                        Case Else
  204.                            If Not ((lvcsplit(ii).lValEnd + 1) = lvcsplit(ii + 1).lValIni) Then
  205.                                lub = (lub + 1)
  206.                                ReDim Preserve lvcsplit(0 To lub)
  207.                                SwapBlockMemoryInCicle VarPtr(lvcsplit(ii)), (VarPtr(lvcsplit(lub)) + LenB(lvcsplit(0))), LenB(lvcsplit(0))
  208.                                lvcsplit(ii + 1).lValIni = lVal
  209.                                lvcsplit(ii + 1).lValEnd = lVal
  210.                            End If
  211.                    End Select
  212.                    RegenerateThis = True
  213.                Else
  214.                    Exit For
  215.                End If
  216.            Next ii
  217.        Else
  218.            ReDim lvcsplit(0 To 0)
  219.            lvcsplit(0).lValIni = lVal
  220.            lvcsplit(0).lValEnd = lVal
  221.        End If
  222.    End If
  223. End Function
  224.  
  225. Private Sub Class_Initialize()
  226. '   //  Constructor de la clase, no tengo por que hacer lo siguiente pero como me estoy adaptando a un standart lo hare.
  227.    bChange = False
  228. End Sub
  229.  
  230.  

uso simple:

Código
  1.  
  2. Option Explicit
  3.  
  4. Private Sub Form_Load()
  5. Dim cls     As cRndNumber
  6. Dim lc      As Long
  7.    Set cls = New cRndNumber
  8.    With cls
  9.    '   //  Este simple codigo probara la velocidad, que de hecho ya es rapido a consideracion de otros que conozco.
  10.        .minval = 0
  11.        .maxval = 99999
  12.        Do While (.GetMore = True)
  13.            DoEvents
  14.            lc = .GetNumRandom
  15.        Loop
  16.        MsgBox "Se recorrieron todos los numeros sin repetir alguno xD"
  17.    '   //  Si se cambian los valores menor y mayor entonces es como si se le aplicara call .Reset
  18.    '   //  Este codigo hara un test de repeticion
  19.        .minval = 0
  20.        .maxval = 99
  21.        Do While (.GetMore = True)
  22.            DoEvents
  23.            Debug.Print .GetNumRandom
  24.        Loop
  25.  
  26.        MsgBox "Se recorrieron todos los numeros sin repetir alguno xD"
  27.    End With
  28. End Sub
  29.  
  30.  

Temibles Lunas!¡.
40  Programación / Programación Visual Basic / [source] Numeros Aleatorio desde X a Y con excepciones. en: 24 Mayo 2011, 08:08 am
.
Lo que hace este código es que crea numero aleatorio desde un valor mínimo a uno valor máximo pero si se encuentra un numero Z entre los mismo JAMAS saldrá como numero aleatorio.

Una breve introducción antes del código fuente...

Aun no pruebo la velocidad...

OJO: Las esecciones no deben repetirse.

Código:
NumerosAleatoriosEx (Numero Inicio, Numero Final, Array de valores a no considerar) {
MatrixRangos() = Realizar una búsqueda de valores para verificar si alguno de los numeros del array estan entre el valor de Inicio o el valor del Final: (un For Next bastara) , y generamos cortes de array's por ejemplo (  Inicio=0 final=10 array={5,8}  este paso genera 3 array que son:  {0,4},{6,7},{9,10} )
iIndice = Generamos un numero aleatorio desde Lbound(MatrixRangos()) hasta Ubound(MatrixRangos())
Retornamos el numero que se genera un numero aleatorio según los rangos que indique MatrixRangos( iIndice )(0) y MatrixRangos( iIndice )(1)
}

Código
  1.  
  2. Option Explicit
  3.  
  4. Private Type stRangos
  5.    lValIni         As Long
  6.    lValEnd         As Long
  7. End Type
  8.  
  9. Public Sub swapNumbers(ByRef lValOne As Long, ByRef lValTwo As Long)
  10. Dim lValTmp         As Long
  11.    lValTmp = lValOne
  12.    lValOne = lValTwo
  13.    lValTwo = lValTmp
  14. End Sub
  15.  
  16. Public Function FixNumbers(ByRef lValMin As Long, lValMax As Long) As Boolean
  17.    If lValMax < lValMin Then
  18.        Call swapNumbers(lValMin, lValMax)
  19.        FixNumbers = True
  20.    End If
  21. End Function
  22.  
  23. Public Function NumeroAleatorio(lValMin As Long, lValMax As Long) As Long
  24.    Call FixNumbers(lValMin, lValMax)
  25.    Call Randomize
  26.    NumeroAleatorio = (lValMin - lValMax) * Rnd + lValMax
  27. End Function
  28.  
  29. Public Function NumeroAleatorioEx(ByVal lValIni As Long, ByVal lValEnd As Long, ParamArray aNoRepet() As Variant) As Long
  30. '   //  Debera pasarse el parametro {aNoRepet} ordenado de menor a mayor ( indice lbound siendo el valor menor y ubound el valor mayor ).
  31. '   //  La funcion Si no puede generar un numero aleatorio retornara {lValIni-1}
  32. On Error GoTo GetNumber
  33. Dim avArray()       As Variant
  34. Dim lUB             As Long
  35. Dim lNextVal        As Long
  36. Dim li              As Long, lIndex         As Long
  37. Dim tRangos()       As stRangos
  38.  
  39.    If (Not IsMissing(aNoRepet)) Then
  40.        If (IsArray(aNoRepet(0))) Then
  41.            avArray = aNoRepet(0)
  42.        Else
  43.            avArray = aNoRepet
  44.        End If
  45.  
  46.        lUB = UBound(avArray)
  47.        Call Start_QuickSort(avArray, AcendetOrder)     '   //  http://infrangelux.hostei.com/index.php?option=com_content&view=article&id=14:artquicksortybublesort&catid=2:catprocmanager&Itemid=8
  48.  
  49.        ReDim tRangos(0 To (lUB + 1))                   '   //  Cache de memoria...
  50.        With tRangos(0)
  51.            .lValIni = lValIni
  52.            .lValEnd = lValEnd
  53.        End With
  54.        lNextVal = lValIni
  55.        lIndex = 0
  56.  
  57.        For li = 0 To lUB
  58.            If (avArray(li) <= lValEnd And _
  59.                avArray(li) > lValIni And _
  60.                lNextVal <> avArray(li)) Then
  61.                If (lNextVal > lValIni) Then
  62.                    lIndex = lIndex + 1
  63.                    With tRangos(lIndex)
  64.                        .lValIni = lNextVal
  65.                        .lValEnd = avArray(li) - 1
  66.                    End With
  67.                    lNextVal = (avArray(li) + 1)
  68.  
  69.                ElseIf (lNextVal = lValIni) Then
  70.                    tRangos(lIndex).lValEnd = avArray(li) - 1
  71.                    lNextVal = (avArray(li) + 1)
  72.  
  73.                End If
  74.            ElseIf (avArray(li) = tRangos(0).lValIni) Then
  75.                lIndex = lIndex - 1
  76.                lNextVal = tRangos(0).lValIni + 1
  77.            Else
  78.                lNextVal = lNextVal + 1
  79.            End If
  80.        Next
  81.  
  82.        If (lIndex > -1) Then
  83.            If ((tRangos(lIndex).lValEnd + 1) <= lValEnd And lNextVal <= lValEnd) Then
  84.                lIndex = lIndex + 1
  85.                ReDim Preserve tRangos(0 To lIndex)
  86.                With tRangos(lIndex)
  87.                    .lValIni = avArray(lUB) + 1
  88.                    .lValEnd = lValEnd
  89.                End With
  90.            Else
  91.                ReDim Preserve tRangos(0 To lIndex)
  92.            End If
  93.  
  94.        ElseIf (lNextVal > lValEnd) Then
  95.            NumeroAleatorioEx = lValIni - 1
  96.            Exit Function
  97.  
  98.        Else
  99.            lIndex = 0
  100.            tRangos(lIndex).lValIni = lNextVal
  101.  
  102.        End If
  103.  
  104.        li = NumeroAleatorio(0, lIndex)
  105.        NumeroAleatorioEx = NumeroAleatorio(tRangos(li).lValIni, tRangos(li).lValEnd)
  106.        Exit Function
  107.  
  108.    End If
  109. GetNumber:
  110.    NumeroAleatorioEx = NumeroAleatorio(lValIni, lValEnd)
  111. End Function
  112.  
  113. Private Sub Form_Load()
  114. Dim ii              As Integer
  115. Dim lres            As Long
  116. Dim vArray()        As Variant
  117.  
  118. Const lValIni       As Long = 5
  119. Const lValEnd       As Long = 10
  120.  
  121.    lres = NumeroAleatorioEx(lValIni, lValEnd)
  122.    ReDim vArray(0 To 0)
  123.    vArray(ii) = lres
  124.    Debug.Print lres
  125.    For ii = 1 To 11
  126.        lres = NumeroAleatorioEx(lValIni, lValEnd, vArray)
  127.        ReDim Preserve vArray(0 To ii)
  128.        vArray(ii) = lres
  129.        If (lres = (lValIni - 1)) Then
  130.            Debug.Print "Ya no se pueden crear mas numeros aleatorios, las esecciones llenan todas las opciones."
  131.        Else
  132.            Debug.Print lres
  133.        End If
  134.    Next ii
  135. End Sub
  136.  
  137.  

Salida del ejemplo:

Código:

 10
 7
 9
 8
 6
 5
Ya no se pueden crear mas numeros aleatorios, las esecciones llenan todas las opciones.
Ya no se pueden crear mas numeros aleatorios, las esecciones llenan todas las opciones.
Ya no se pueden crear mas numeros aleatorios, las esecciones llenan todas las opciones.
Ya no se pueden crear mas numeros aleatorios, las esecciones llenan todas las opciones.
Ya no se pueden crear mas numeros aleatorios, las esecciones llenan todas las opciones.
Ya no se pueden crear mas numeros aleatorios, las esecciones llenan todas las opciones.


Temibles Lunas!¡.
Páginas: 1 2 3 [4] 5 6 7 8 9 10 11 12 13 14
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines