Wrapping Around an Integer visual basic

[Verwijderd]

wie weet hoe je in Visual Baisc of VBScript het volgende kan doen

Ik heb een integer die rond moet tellen

in C++ kan je dit simpel doen via waarde++ dan teld hij fijn rond
bij Visual basic krijg je bij Intwaarde + 1 een overflow error zodra hij op zijn maximum waarde van zijn integer zit.

Hoe kan ik in Visual basic of VBScript een integer rond laten tellen

[Woy]

Controleren of je de maximum value bereikt hebt en dan weer op de minimum value zetten.

[whoami]

Ben je dat zeker dat dat standaard gedrag is in C++ ?

[RobIII]

Visual Basic:

    T = 0
    Do
        If T < 32767 Then T = T + 1 Else T = -32768
        Debug.Print T
    Loop

Zie ook http://msdn.microsoft.com/.../vbsdatatype.asp (Is voor VBScript, maar dat geldt ook voor VB6). Ik kon de VB6 versie zo snel niet vinden...

http://msdn.microsoft.com/.../vagrpDataType.asp voor VBA...

whoami schreef op 09 november 2004 @ 14:10:
Ben je dat zeker dat dat standaard gedrag is in C++ ?

In C# iig wel , maar volgens mij in C++ ook...

C#:

private void Form1_Load(object sender, System.EventArgs e)
{
    byte bla = 0;
    this.Show();
    while (true) 
    {
        bla++;
        label1.Text=bla.ToString();
        label1.Refresh();
    }
}

(voorbeeldje effe met een byte gedaan, dat duurt niet zo lang )

[ Voor 107% gewijzigd door RobIII op 09-11-2004 14:32 ]

[Woy]

whoami schreef op 09 november 2004 @ 14:10:
Ben je dat zeker dat dat standaard gedrag is in C++ ?

volgens mij wel. standaard negeert hij volgens mij gewoon de overflow bit en dus komt het er op neer dat je weer op de minvalue van een int zit.

[Verwijderd]

RobIII

Je VB Voorbeeldje is leuk en ongeveer wat ik bedoel

alleen nu wil ik niet 1 waarde ophogen met 1
maar een waarde op hogen met een willekeurig getal
nu kan je wel iets met een for loop doen en dan elke keer 1 ophogen maar dat lijkt me niet zo efficient

waar ik het voor wil gebruiken is voor een spelletje wat ik aan het maken ben
nu heb ik een 2D map die loopt van de minimum tot de maximum waarde loopt van een integer.
nu is dat niet z'n probleem maar ik wil dat de kaart rond loopt
en de verplaatsing van elk object binnen die kaart is variabel
dus de eene kan 1 integer waarde verplaatsen en de andere mischien wel 20 integer's

iemand een idee hier voor

[RobIII]

Verwijderd schreef op 09 november 2004 @ 14:40:
RobIII

Je VB Voorbeeldje is leuk en ongeveer wat ik bedoel

alleen nu wil ik niet 1 waarde ophogen met 1
maar een waarde op hogen met een willekeurig getal

Kom op zeg, er staat gewoon in de code T = T + 1, dat moet toch niet zo moeilijk aan te passen zijn? En anders pak je gewoon een Long, daar past een integer makkelijker in

Dit is wel erg basic...

Visual Basic:

Private Sub Bla
    Dim T As Integer
    
    Do
        T = AddInteger(T, Rnd * 1000)
        Debug.Print T
    Loop
End Sub

Private Function AddInteger(iStart As Integer, iAdd As Integer) As Integer
    Dim lTemp As Long
    
    lTemp = CLng(iStart) + CLng(iAdd)
    If lTemp > 32767 Then
        AddInteger = -32768 + (lTemp - 32767)
    Else
        AddInteger = lTemp
    End If
End Function

En anders kan je met een CopyMemory call wel een long in een int frotten en zo de "overflow" negeren. Maar dat mag je zelf uitzoeken

[ Voor 84% gewijzigd door RobIII op 09-11-2004 14:50 ]

[Verwijderd]

Kan je die int niet in een long gooien en dan een if die long groter is dan 32767 dan de nieuwe T op die -32767 + het verschil tussen de waarde van die long -32767?

[d00d]

Ik ben al zoveel over VB vergeten dat ik het niet meer in notepad voor elkaar krijg, maar in C# kun je gebruik maken van de 'unchecked' optie, als in:

code:

using System;

class CheckedClass
{
    public static void Main()
    {
        short i = short.MaxValue - 5;
        unchecked
        {
            for (int j = 0; j <= 9; j++)
            {
                Console.WriteLine(i++);
            }
        }       
    }
}

Het resultaat is dan:

code:

32762
32763
32764
32765
32766
32767
-32768
-32767
-32766
-32765

Er wordt dus door de unchecked optie geen overflow gegenereerd en je kunt dus 'rond tellen'. Je kunt ook je hele applicatie compileren met de unchecked optie, maar dat raad ik je niet aan

[Verwijderd]

Verwijderd schreef op 09 november 2004 @ 14:40:
(...) maar ik wil dat de kaart rond loopt
en de verplaatsing van elk object binnen die kaart is variabel
dus de eene kan 1 integer waarde verplaatsen en de andere mischien wel 20 integer's

iemand een idee hier voor

Je kaart maak je leidend coordinaat-systeem. De linker onderhoek van je kaart leg je op (0, 0). Als je coordinaten zijn dan positief.
Vervolgens kan je coordinaten van objecten met de modulo functie bewerken en vallen ze altijd netjes op de kaart.

[RobIII]

d00d schreef op 09 november 2004 @ 15:21:
Ik ben al zoveel over VB vergeten dat ik het niet meer in notepad voor elkaar krijg, maar in C# kun je gebruik maken van de 'unchecked' optie, als in:
<knip>
Er wordt dus door de unchecked optie geen overflow gegenereerd en je kunt dus 'rond tellen'. Je kunt ook je hele applicatie compileren met de unchecked optie, maar dat raad ik je niet aan

uhm, c# is nogal nieuw voor me (in de zin dat ik er niet dagelijks in werk, maar er wel veel over gelezen heb en er soms mee stoei), maar mijn voorbeeld werkt zonder unchecked ook gewoon met een short

[Verwijderd]

Ja das leuk maar ik gebruik al een long in de uiteindelijke versie
En wil van deze datatype ook de maximale waarde kunnen gebruiken

Wat hij gewoontjes moet doen is rondlopen in zijn telling en niet de overflow bit checken (Dit kan selfs in ASM heeeel simpel) waarom geeft VB me alleen maar Overflow error's

[riezebosch]

Als 0 je minvalue is kan je mooi met modulo werken (geen idee wat daarvan de syntax is in VB)

[d00d]

RobIII schreef op 09 november 2004 @ 15:30:
[...]

uhm, c# is nogal nieuw voor me (in de zin dat ik er niet dagelijks in werk, maar er wel veel over gelezen heb en er soms mee stoei), maar mijn voorbeeld werkt zonder unchecked ook gewoon met een short

Ja, dat kan wel zo zijn, maar mijn voorbeeld is mooier en doet precies wat de TS vraagt, namelijk het uitzetten van de overflow check!

[Verwijderd]

d00d

Jou voorbeeld in C# is inderdaad wat ik wil in VB het uitzetten van de overflow
maar hoe doen we dat ??

het voorbeeld van RobII is wat minder gewilt bij mij aangezien dit erg veel CPU load kan genereren

en aagezien overflow chekken iets is wat geintroduceert is door de programmeertalen zou je denken dat je dat ook uit moet kunnen zetten.

d00d mischien kan jij mij nog vertellen wat een vergelijkbare optie in VB is

[Robtimus]

Controleren of waarde <= MAX - optelling:

Visual Basic:

If intT <= 32767 - intA Then
    intT = intT + intA
Else
    intT = -32768 + (intT - 32767 + intA)
End If

Blijft de rechterkant van je vergelijking ook binnen de Integer waarden.

[ Voor 3% gewijzigd door Robtimus op 09-11-2004 15:46 ]

[Verwijderd]

IceManX

Wat is IntT en IntA in je code ??

[riezebosch]

waarde MODULO (MAXWAARDE+1) + MINWAARDE

vb:
range: -4 -3 -2 -1 0 1 2 3 4
maxwaarde = 4
minwaarde = -4

waarde = 5
uitkomst: 5 MODULO 5 + -4 = -4

[Robtimus]

intT is je Integer die moet wrappen, intA is een willekeurige integer die je daarbij optelt. Is dus algemener dan alleen voor 1.

[Robtimus]

riezebosch schreef op 09 november 2004 @ 15:55:
waarde MODULO (MAXWAARDE+1) + MINWAARDE

vb:
range: -4 -3 -2 -1 0 1 2 3 4
maxwaarde = 4
minwaarde = -4

waarde = 5
uitkomst: 5 MODULO 5 + -4 = -4

En als de waarde 15 is? Dan moet er -3 uitkomen, maar zo komt er -4 uit.

En MAXWAARDE+1 levert juist een overflow op (tenzij je daar een long voor gebruikt).

[Verwijderd]

IceManX
Ik begin hem te snappen
maar deze werkt dan niet volgens mij als je je negative beweegt ?? of zie ik dat verkeert

Wel jammer dat C# dit ff efficienter kan dan VB - puntje VB

[Robtimus]

Verwijderd schreef op 09 november 2004 @ 15:59:
IceManX
Ik begin hem te snappen
maar deze werkt dan niet volgens mij als je je negative beweegt ?? of zie ik dat verkeert

Wel jammer dat C# dit ff efficienter kan dan VB - puntje VB

Klopt, maar dan draai je het om:

Visual Basic:

' intA is negatief!
If intT >= -32768 - intA Then
    intT = intT + intA
Else
    intT = 32767 - (intT - (-32768 - intA))
    ' intA < 0, dus -32768 - intA > -32768
End If

(kan een klein foutje in het laatste deel zijn geslopen)

Let op dat ik idd een -- gebruik, maar dat is omdat 32768 een Long constant is en geen Integer.

[ Voor 11% gewijzigd door Robtimus op 09-11-2004 16:05 ]

[.oisyn]

whoami schreef op 09 november 2004 @ 14:10:
Ben je dat zeker dat dat standaard gedrag is in C++ ?

De standaard doet hier volgens mij geen uitspraak over... Maar goed, het is gewoon standaard gedrag voor vrijwel elke CPU

[abeker]

Je kunt de overflow checks uitzetten in VB. Zit in Project -> "jouwproject" Properties -> Compile -> Advanced Optimizations -> Remove Integer Overflow Checks

Nadeel is wel dat dit alleen werkt in gecompileerde versies van je programma.

[Verwijderd]

abeker

das een leuke optie maar kan je dat ook alleen voor 1 funtie of een gedeelte van de code doen ??

[abeker]

Helaas kun je niet zelf stukken code aangeven waarbij de overflow check uitgeschakeld moet worden. Als het echt moet, kun je wel een dll maken met daarin de functies waarbij de overflow check gedisabled moet zijn.

[riezebosch]

IceManX schreef op 09 november 2004 @ 15:58:
[...]
En als de waarde 15 is? Dan moet er -3 uitkomen, maar zo komt er -4 uit.

En MAXWAARDE+1 levert juist een overflow op (tenzij je daar een long voor gebruikt).

Hij klopt inderdaad niet, want bij 10 komt er ook een verkeerde waarde uit. Toch ben ik van mening dat je het enorm elegant op kan lossen met behulp van de modulo...

[Robtimus]

Als de ondergrens 0 is zeer zeker.

Voor een spel/map zou ik dat ook eerder doen, met (0,0) de linkerbovenhoek. Dan gaan alle berekeningen lekker modulo veldgrootte (evt met een +veldgrootte om een negatieve modulo te voorkomen).

[riezebosch]

IceManX: jouw code werkt volgens mij ook niet bij waardes groter dan twee keer de grote van de range... Dan kom je ook alsnog buiten de range terecht (zelfde als in mijn pseudo-code).

[Robtimus]

Maar als de range van MIN_INT naar MAX_INT loopt, dan kunnen intT en intA daar ook nooit buiten vallen, want dat zijn integers. Die zijn dus ook gebonden aan MIN_INT en MAX_INT.

In principe heb je wel gelijk, gebruik je in jouw code ook MAX_INT en MIN_INT, dan krijg je dat probleem ook niet (maar wel de modulo MAX_INT + 1).

[muba]

Neem een ander datatype dan int. Double of long ofzo.
Zodra de waarde daarvan groter wordt dan je kaart, dan min je heb gewoon zelf.

Maak dus iets van een

code:

function addem (byval thevalue as long, byval addbythis as long) as long
    thevalue = thevalue + addbythis
    if thevalue > 32767 then thevalue = -32768 + (thevalue - 32767)
end function

Wordt thevalue groter dan 32767, dan wordt de waarde terug gezet naar de minimum maar het verschil (tussen thevalue en de maximumwaarde) wordt wel gelijk meegenomen.

[MSalters]

.oisyn schreef op 09 november 2004 @ 16:16:
[...]
De standaard doet hier volgens mij geen uitspraak over... Maar goed, het is gewoon standaard gedrag voor vrijwel elke CPU

De C++ standaard (net zoals C) garandeert wrap-around gedrag voor unsigned integers. 'gewoon' int mag een NaN hebben, of andere traps.

[Verwijderd]

Wel leuke oplossing van Ice

alleen weet iemand nog een oplossing ala C++
maar dan in VB

want volgens mij is de code in C++ aanzienlijk sneller aangezien hier geen If Constcutie voor nodig is in C++ om het zelfde te bekrijken
en om nou een DLL te bouwen in C++ alleen voor dit doel is een beetje overkill

iemand een idee ?? post hem dan ff

[Maasluip]

Om te beginnen: ik zou niet op dit gedrag in C++ rekenen om iets te programmeren. Zeker niet als je code portable moet zijn (en dan bedoel ik nog niet eens over verschillende machines, maar zelfs verschillende compilers). Afhankelijk van de compiler kan een int intern namelijk best als een long int worden gedeclareerd en dan tel je dus verder door.

In VB zou je een error handler kunnen maken. On Error in het begin van de sub/functie en in de errorhandler op de error voor overflow testen. Zonder if's kom je er anders niet uit.

[Verwijderd]

Hmm vet irrietant

Zelf in ASM kan je dit soort rond tellen supper simpel doen
en in C++ kan je ASM blokken toevoegen

Waaom in VB nu niet (Grrr)

[.oisyn]

Maasluip schreef op 10 november 2004 @ 10:14:
Afhankelijk van de compiler kan een int intern namelijk best als een long int worden gedeclareerd en dan tel je dus verder door.

Nou nee dat kan dus niet, een int is altijd een ander type dan een long int. Ze kunnen natuurlijk wel even groot zijn, wat meestal ook het geval is op 32 bits platforms. Je hebt gelijk dat je niet kunt rekenen op een vaste grootte van een int, maar hij zal iig altijd CHAR_BIT * sizeof (int) bits hebben

[Maasluip]

.oisyn schreef op 10 november 2004 @ 10:43:
[...]

Nou nee dat kan dus niet, een int is altijd een ander type dan een long int. Ze kunnen natuurlijk wel even groot zijn, wat meestal ook het geval is op 32 bits platforms. Je hebt gelijk dat je niet kunt rekenen op een vaste grootte van een int, maar hij zal iig altijd CHAR_BIT * sizeof (int) bits hebben

Helaas, dat is dus niet zo.
Ik meen me te herinneren dat op VMS de int 32-bit is. Daarom gebruikten wij voor portability de int niet en hadden een eigen INT32 en INT16 en CHAR datatype gedefinieerd (portability tussen VMS en NT, je begrijpt best dat een malloc(sizeof(int)) vervelende dingen kan doen als je int soms 16, soms 32 bit is).

Als gaat het over het (niet) gelijk zijn van int en long: in AIX 32bit is een int 32 bits en een long 32 bits, in AIX 64bit is een int nog altijd 32 bit en een long 64 bit. Het kan dus echt verkeren.

En RobIII in "Wrapping Around an Integer visual basic" gaat er zelfs van uit dat een int 16 bit is, wat klopt in VB, maar meestal niet in C.

Blijft de conclusie dat je voor portabiliteit er niet van uit kunt gaan dat een bepaald datatype altijd hetzelfde aantal bits is.

[.oisyn]

Je begrijpt niet wat ik zeg. Ik zei dat int en long int verschillende typen zijn, het kan dus niet zijn dat de compiler "een int declareert als een long int", zoals jij zei. Dat zou betekenen dat je hier een compile error zou krijgen:

C++:

void func (int) { }
void func (long) { }  // error, want int == long

Dat is niet zo. Wat wel zo is is dat een int net zo groot kan zijn als een long, wat ik dus in mijn vorige post zei en wat jij bedoelt.

je begrijpt best dat een malloc(sizeof(int)) vervelende dingen kan doen als je int soms 16, soms 32 bit is

Nee, dat begrijp ik niet. Een malloc (sizeof (int)) (of beter: new int) geeft altijd voldoende ruimte om een int in op te slaan. Dat het afgezien van dat vervelend is dat de grootte van een int kan wijzigen is natuurlijk wel waar.

[riezebosch]

Mooi voorbeeld: in VC7.1 loopt een int tot maar liefst 2147483647 Ik zou dus niet echt op dat gedrag van rondlopen vertrouwen... Deze code werkt voor mij iig goed in C++ (moet niet zo moeilijk te porten zijn naar VB), maar zoals IceManX al aangeeft moet je niet echt tot het uiterste van de grenswaarden gaan want dan gaat de berekening met (MaxValue + MinValue*-1 +1) niet goed...

C++:

const int MaxValue = 32767;
const int MinValue = -32768;

int rondGetal(int i)
{
    return (i + MinValue*-1) % (MaxValue + MinValue*-1 +1) - MinValue*-1;
}

[MSalters]

Om daarvoor nou VC7.1 te nemen, alle 32-bits versie van MSVC doen dat (sinds VC2). short is daar wel 16 bits, met de verwachte wraparound. Maar goed, short is signed en de range is sowieso implementatio-defined, dus dat is allemaal niet standaard.

De correcte oplossing is (wiskundig)

x+1 = (x-INT_MIN+1) modulo (INT_MAX-INT-MIN+1) + INT_MIN

vb INT_MIN = -2, INT_MAX = 1,
x=0 -> x+1 = (0+2+1) modulo (1--2+1) + -2 = 3 - 2 = 1
x=1 -> x+1 = (1+2+1) modulo (1--2+1) + -2 = 0 - 2 = -2
x=-2 -> x+1 = (-2+2+1) modulo (1--2+1) + -2 = 1 - 2 = -1

etcetera

[EXX]

Verwijderd schreef op 09 november 2004 @ 15:59:Wel jammer dat C# dit ff efficienter kan dan VB - puntje VB

Niks - puntje voor VB.

Deze manier van proggen beschouw ik als not-done. Je bent erg compiler afhankelijk, ook bij C/C++. De warp around is een verborgen operatie, voor maintenance programmers zijn zulke dingen een hel. Talen als Pascal, Modula-2 en Ada laten dit ook niet toe.

offtopic:

Wat betreft verschillende lengtes(8/16/32 bit): ik gebruik in mijn C code altijd een portab.h:

code:

#ifndef   PORTAB_H

typedef enum BOOLEAN
 {
  FALSE = (1!=1),
  TRUE  = (1==1)
 } BOOLEAN;

typedef char          CHAR;         /* charachter                    */
typedef void          VOID;         /* void function return          */
typedef float         FLOAT;        /* floating point                */
typedef double        DOUBLE;       /* double precision              */

typedef unsigned char UINT_8;       /* unsigned byte ( 8 bits)       */
typedef   signed char  INT_8;       /*   signed byte ( 8 bits)       */
typedef unsigned int  UINT_16;      /* unsigned word (16 bits)       */
typedef   signed int   INT_16;      /*   signed word (16 bits)       */
typedef unsigned long UINT_32;      /* unsigned long (32 bits)       */
typedef   signed long  INT_32;      /*   signed long (32 bits)       */

#define REG      register           /* register variable             */
#define EXTERN   extern             /* external variavle             */
#define DEFAULT  int                /* default size                  */

#define GLOBAL   /* static  */     /* Global variable, static        */
#define MGLOBAL  static            /* Modul global variable, static  */
#define FGLOBAL static const       /* Read only static table in Func */


/*********************************************************************/
/*                Miscellaneous Definitions:                         */
/*********************************************************************/

#define FOREVER  for(;;)           /* Infinite loop declaration      */
#define NULL     0                 /* Null character value           */
#define NULLPTR  (void *)0         /* Null pointer value             */

#define BIT_0          0x01        /* Bit  0 of 16                   */
#define BIT_1          0x02        /* Bit  1 of 16                   */
#define BIT_2          0x04        /* Bit  2 of 16                   */
#define BIT_3          0x08        /* Bit  3 of 16                   */
#define BIT_4          0x10        /* Bit  4 of 16                   */
#define BIT_5          0x20        /* Bit  5 of 16                   */
#define BIT_6          0x40        /* Bit  6 of 16                   */
#define BIT_7          0x80        /* Bit  7 of 16                   */
#define BIT_8         0x100        /* Bit  8 of 16                   */
#define BIT_0         0x200        /* Bit  9 of 16                   */
#define BIT_10        0x400        /* Bit 10 of 16                   */
#define BIT_11        0x800        /* Bit 11 of 16                   */
#define BIT_12       0x1000        /* Bit 12 of 16                   */
#define BIT_13       0x2000        /* Bit 13 of 16                   */
#define BIT_14       0x4000        /* Bit 14 of 16                   */
#define BIT_15       0x8000        /* Bit 15 of 16                   */

#define BIT_16    0x010000L        /* Bit 16 of 32                   */
#define BIT_17    0x020000L        /* Bit 17 of 32                   */
#define BIT_18    0x040000L        /* Bit 18 of 32                   */
#define BIT_19    0x080000L        /* Bit 19 of 32                   */
#define BIT_20    0x100000L        /* Bit 20 of 32                   */
#define BIT_21    0x200000L        /* Bit 21 of 32                   */
#define BIT_22    0x400000L        /* Bit 22 of 32                   */
#define BIT_23    0x800000L        /* Bit 23 of 32                   */
#define BIT_24   0x1000000L        /* Bit 24 of 32                   */
#define BIT_25   0x2000000L        /* Bit 25 of 32                   */
#define BIT_26   0x4000000L        /* Bit 26 of 32                   */
#define BIT_27   0x8000000L        /* Bit 27 of 32                   */
#define BIT_28  0x10000000L        /* Bit 28 of 32                   */
#define BIT_29  0x20000000L        /* Bit 29 of 32                   */
#define BIT_30  0x40000000L        /* Bit 30 of 32                   */
#define BIT_31  0x80000000L        /* Bit 31 of 32                   */

#define  PORTAB_H

#endif

gewoon overal includen en alleen de zelf gedefinieerde datatypes als INT_16 etc. gebruiken.

[ Voor 3% gewijzigd door EXX op 10-11-2004 13:48 ]

[riezebosch]

MSalters schreef op 10 november 2004 @ 13:28:
[...]
De correcte oplossing is (wiskundig)

x+1 = (x-INT_MIN+1) modulo (INT_MAX-INT-MIN+1) + INT_MIN

vb INT_MIN = -2, INT_MAX = 1,
x=0 -> x+1 = (0+2+1) modulo (1--2+1) + -2 = 3 - 2 = 1
x=1 -> x+1 = (1+2+1) modulo (1--2+1) + -2 = 0 - 2 = -2
x=-2 -> x+1 = (-2+2+1) modulo (1--2+1) + -2 = 1 - 2 = -1

etcetera

Grappig, je geeft eigenlijk exact dezelfde oplossing als ik, alleen doe jij x ook al plus 1 en heeft je uitkomst dus ook een extra

[d00d]

Wat je ook kunt doen is een 32 bit Int gebruiken en vervolgens de eerst 16 bits naar links en dan weer 16 bits naar rechts shiften. Ook dan krijg je eigenlijk een 'rond tellende' Short (Int16).

code:

Imports System

Module Hello
    Sub Main()
        Dim j As Int32, i As Int32
        j = Short.MaxValue - 5
        For i = 0 To 10
            Console.WriteLine((j << 16) >> 16)
            j = j + 1
        Next
    End Sub
End Module

Uitkomst

code:

32762
32763
32764
32765
32766
32767
-32768
-32767
-32766
-32765
-32764

Zelfde resultaat als gisteren
Ik heb het zelfs in VB gemaakt voor je...