Hi,
VT_R4: 7.850 -> VarRound(1) -> 7.800 VT_R4: 7.851 -> VarRound(1) -> 7.900 Is this the binary representation (in)accuracy?
MS state that rounding is dependent on the internal binary representation of the number and thus VarRound doesn't always get it right, i.e. you can't tell with any certainty what the result will be. You have 2 choices: try and match their exact algorithm (v. hard w/o reverse engineering) or use the dutch rounding method (this makes more sense IMO).
How can I test if the rounding worked ok when the numbers may differ in the last (invisible) bits?
As long as Wine does the right thing don't worry about it.
And how should I round a currency? It's valid on Windows but I couldn't interpret the results. Is this some kind of fixed comma type?
The currency value is multiplied by 10000 and stored in an I8 (See the VarCy* functions). So it has 4 dp of precision. To round to:
4 dp or more => no op. 0 dp => / 10000, then * 10000 1 dp => / 1000, then * 1000 2 dp => / 100, then * 100 3 dp => / 10, then * 10
mults and divs should be done on the I8 directly (no float).
Cheers, Jon
===== "Don't wait for the seas to part, or messiahs to come; Don't you sit around and waste this chance..." - Live
jon_p_griffiths@yahoo.com
__________________________________ Do you Yahoo!? Yahoo! Mail SpamGuard - Read only the mail you want. http://antispam.yahoo.com/tools
be. You have 2 choices: try and match their exact algorithm (v. hard w/o reverse engineering) or use the dutch rounding method (this makes more sense IMO).
I couldn't find anything about "Dutch rounding". Isn't rounding exactly defined? 0.1-0.4 round down -> 0.0, 0.5-0.9 round up -> 1.0?
And how should I round a currency? It's valid on Windows but I couldn't interpret the results. Is this some kind of fixed comma type?
The currency value is multiplied by 10000 and stored in an I8 (See the VarCy* functions). So it has 4 dp of precision. To round to:
4 dp or more => no op. 0 dp => / 10000, then * 10000 1 dp => / 1000, then * 1000 2 dp => / 100, then * 100 3 dp => / 10, then * 10
mults and divs should be done on the I8 directly (no float).
I think I did it like this now. Still the DECIMAL part is missing. The tests in the test_VarRound are commented out as compares on floats are quite useless. Unless somebody finds a better way to test if the rounding worked ok I'll remove them (which would be a pity).
bye Fabi
Index: wine/dlls/oleaut32/oleaut32.spec =================================================================== RCS file: /home/wine/wine/dlls/oleaut32/oleaut32.spec,v retrieving revision 1.64 diff -u -r1.64 oleaut32.spec --- wine/dlls/oleaut32/oleaut32.spec 21 Jan 2004 22:24:08 -0000 1.64 +++ wine/dlls/oleaut32/oleaut32.spec 23 Feb 2004 10:46:42 -0000 @@ -170,7 +170,7 @@ 172 stdcall VarInt(ptr ptr) 173 stdcall VarNeg(ptr ptr) 174 stdcall VarNot(ptr ptr) -175 stub VarRound # stdcall (ptr long ptr) +175 stdcall VarRound(ptr long ptr) 176 stdcall VarCmp(ptr ptr long long) 177 stdcall VarDecAdd(ptr ptr ptr) 178 stdcall VarDecDiv(ptr ptr ptr) Index: wine/dlls/oleaut32/variant.c =================================================================== RCS file: /home/wine/wine/dlls/oleaut32/variant.c,v retrieving revision 1.87 diff -u -r1.87 variant.c --- wine/dlls/oleaut32/variant.c 17 Feb 2004 20:25:41 -0000 1.87 +++ wine/dlls/oleaut32/variant.c 23 Feb 2004 10:46:43 -0000 @@ -3436,6 +3436,135 @@
return hRet; } + + +/********************************************************************** + * VarRound [OLEAUT32.175] + * + * Perform a round operation on a variant. + * + * PARAMS + * pVarIn [I] Source variant + * deci [I] Number of decimals to round to + * pVarOut [O] Destination for converted value + * + * RETURNS + * Success: S_OK. pVarOut contains the converted value. + * Failure: An HRESULT error code indicating the error. + * + * NOTES + * - Floating point values are rounded to the desired number of decimals. + * - Negative values are rounded nearer to zero (and not bigger in absolute). + * - Some integer types are just copied to the return variable. + * - Some other integer types are not handled and fail. + */ +HRESULT WINAPI VarRound(LPVARIANT pVarIn, int deci, LPVARIANT pVarOut) +{ + VARIANT varIn; + HRESULT hRet = S_OK; + float factor; + + TRACE("(%p->(%s%s),%d)\n", pVarIn, debugstr_VT(pVarIn), debugstr_VF(pVarIn), deci); + + switch (V_VT(pVarIn)) + { + /* cases that fail on windows */ + case VT_I1: + case VT_I8: + case VT_UI2: + case VT_UI4: + hRet = DISP_E_BADVARTYPE; + break; + + /* cases just copying in to out */ + case VT_UI1: + V_VT(pVarOut) = V_VT(pVarIn); + V_UI1(pVarOut) = V_UI1(pVarIn); + break; + case VT_I2: + V_VT(pVarOut) = V_VT(pVarIn); + V_I2(pVarOut) = V_I2(pVarIn); + break; + case VT_I4: + V_VT(pVarOut) = V_VT(pVarIn); + V_I4(pVarOut) = V_I4(pVarIn); + break; + case VT_NULL: + V_VT(pVarOut) = V_VT(pVarIn); + /* value unchanged */ + break; + + /* cases that change type */ + case VT_EMPTY: + V_VT(pVarOut) = VT_I2; + V_I2(pVarOut) = 0; + break; + case VT_BOOL: + V_VT(pVarOut) = VT_I2; + V_I2(pVarOut) = V_BOOL(pVarIn); + break; + case VT_BSTR: + hRet = VarR8FromStr(V_BSTR(pVarIn), LOCALE_USER_DEFAULT, 0, &V_R8(&varIn)); + if (FAILED(hRet)) + break; + pVarIn = &varIn; + /* Fall through ... */ + + /* cases we need to do math */ + case VT_R8: + if (V_R8(pVarIn)>0) { + V_R8(pVarOut)=floor(V_R8(pVarIn)*pow(10, deci)+0.5)/pow(10, deci); + } else { + V_R8(pVarOut)=ceil(V_R8(pVarIn)*pow(10, deci)-0.5)/pow(10, deci); + } + V_VT(pVarOut) = V_VT(pVarIn); + break; + case VT_R4: + if (V_R4(pVarIn)>0) { + V_R4(pVarOut)=floor(V_R4(pVarIn)*pow(10, deci)+0.5)/pow(10, deci); + } else { + V_R4(pVarOut)=ceil(V_R4(pVarIn)*pow(10, deci)-0.5)/pow(10, deci); + } + V_VT(pVarOut) = V_VT(pVarIn); + break; + case VT_DATE: + if (V_DATE(pVarIn)>0) { + V_DATE(pVarOut)=floor(V_DATE(pVarIn)*pow(10, deci)+0.5)/pow(10, deci); + } else { + V_DATE(pVarOut)=ceil(V_DATE(pVarIn)*pow(10, deci)-0.5)/pow(10, deci); + } + V_VT(pVarOut) = V_VT(pVarIn); + break; + case VT_CY: + if (deci>3) + factor=1; + else + factor=pow(10, 4-deci); + + if (V_CY(pVarIn).int64>0) { + V_CY(pVarOut).int64=floor(V_CY(pVarIn).int64*factor)/factor; + } else { + V_CY(pVarOut).int64=ceil(V_CY(pVarIn).int64*factor)/factor; + } + V_VT(pVarOut) = V_VT(pVarIn); + break; + + /* cases we don't know yet */ + default: + FIXME("unimplemented part, V_VT(pVarIn) == 0x%X, deci == %d\n", + V_VT(pVarIn) & VT_TYPEMASK, deci); + hRet = DISP_E_BADVARTYPE; + } + + if (FAILED(hRet)) + V_VT(pVarOut) = VT_EMPTY; + + TRACE("returning 0x%08lx (%s%s),%f\n", hRet, debugstr_VT(pVarOut), + debugstr_VF(pVarOut), V_VT(pVarOut) == VT_R4 ? V_R4(pVarOut):-1); + + return hRet; +} +
/********************************************************************** * VarMod [OLEAUT32.154] Index: wine/dlls/oleaut32/tests/vartest.c =================================================================== RCS file: /home/wine/wine/dlls/oleaut32/tests/vartest.c,v retrieving revision 1.23 diff -u -r1.23 vartest.c --- wine/dlls/oleaut32/tests/vartest.c 6 Feb 2004 05:23:48 -0000 1.23 +++ wine/dlls/oleaut32/tests/vartest.c 23 Feb 2004 10:46:47 -0000 @@ -2548,6 +2548,129 @@ "VarNeg: VT_CY wrong, hres=0x%lX\n", hres); }
+static HRESULT (WINAPI *pVarRound)(LPVARIANT,int,LPVARIANT); + +#define VARROUND(vt,val,deci,rvt,rval) V_VT(&v) = VT_##vt; V_##vt(&v) = val; \ + memset(&vDst,0,sizeof(vDst)); hres = pVarRound(&v,deci,&vDst); \ + ok(hres == S_OK && V_VT(&vDst) == VT_##rvt && V_##rvt(&vDst) == (rval), \ + "VarRound: expected 0x0,%d,%d, got 0x%lX,%d,%d\n", VT_##rvt, (int)(rval), \ + hres, V_VT(&vDst), (int)V_##rvt(&vDst)) + +#define VARROUNDF(vt,val,deci,rvt,rval) V_VT(&v) = VT_##vt; V_##vt(&v) = val; \ + memset(&vDst,0,sizeof(vDst)); hres = pVarRound(&v,deci,&vDst); \ + ok(hres == S_OK && V_VT(&vDst) == VT_##rvt && V_##rvt(&vDst) == (rval), \ + "VarRound: expected 0x0,%d,%f, got 0x%lX,%d,%f\n", VT_##rvt, rval, \ + hres, V_VT(&vDst), V_##rvt(&vDst)) + +static void test_VarRound(void) +{ + static const WCHAR szNumMin[] = {'-','1','.','4','5','\0' }; + static const WCHAR szNum[] = {'1','.','4','5','\0' }; + HRESULT hres; + VARIANT v, vDst; + DECIMAL *pdec = &V_DECIMAL(&v); + CY *pcy = &V_CY(&v); + + CHECKPTR(VarRound); + + /* first check valid integer types */ + VARROUND(BOOL,VARIANT_TRUE,0,I2,-1); + VARROUND(BOOL,VARIANT_FALSE,0,I2,0); + VARROUND(BOOL,1,0,I2,1); + VARROUND(UI1,1,0,UI1,1); + VARROUND(UI1,254,0,UI1,254); + VARROUND(I2,-32768,0,I2,-32768); + VARROUND(I2,-1,0,I2,-1); + VARROUND(I2,1,0,I2,1); + VARROUND(I4,-((int)(~0u >> 1)) - 1,0,I4,-((int)(~0u >> 1)) - 1); + VARROUND(I4,-1,0,I4,-1); + VARROUND(I4,1,0,I4,1); + + + /* MSDN states that rounding of R4/R8 is dependent on the underlying + * bit pattern of the number and so is architecture dependent. So we + * can check if the dest type and hres are ok but not more. + */ + + VARROUNDF(R4,1.0,0,R4,1.0); + VARROUNDF(R4,-1.0,0,R4,-1.0); + VARROUNDF(R8,1.0,0,R8,1.0); + VARROUNDF(R8,-1.0,0,R8,-1.0); + + /* floating point numbers aren't exactly equal and we can't just + * compare the first few digits. + todo_wine { + VARROUNDF(DATE,1.451,1,DATE,1.5); + VARROUNDF(DATE,-1.45,1,DATE,-1.4); + VARROUNDF(BSTR,(BSTR)szNumMin,1,R8,-1.40); + VARROUNDF(BSTR,(BSTR)szNum,1,R8,1.50); + + VARROUNDF(R4,1.23456,0,R4,1.0); + VARROUNDF(R4,1.23456,1,R4,1.2); + VARROUNDF(R4,1.23456,2,R4,1.23); + VARROUNDF(R4,1.23456,3,R4,1.235); + VARROUNDF(R4,1.23456,4,R4,1.2346); + VARROUNDF(R4,-1.23456,0,R4,-1.0); + VARROUNDF(R4,-1.23456,1,R4,-1.2); + VARROUNDF(R4,-1.23456,2,R4,-1.23); + VARROUNDF(R4,-1.23456,3,R4,-1.235); + VARROUNDF(R4,-1.23456,4,R4,-1.2346); + + VARROUNDF(R8,1.23456,0,R8,1.0); + VARROUNDF(R8,1.23456,1,R8,1.2); + VARROUNDF(R8,1.23456,2,R8,1.23); + VARROUNDF(R8,1.23456,3,R8,1.235); + VARROUNDF(R8,1.23456,4,R8,1.2346); + VARROUNDF(R8,-1.23456,0,R8,-1.0); + VARROUNDF(R8,-1.23456,1,R8,-1.2); + VARROUNDF(R8,-1.23456,2,R8,-1.23); + VARROUNDF(R8,-1.23456,3,R8,-1.235); + VARROUNDF(R8,-1.23456,4,R8,-1.2346); + } + */ + + V_VT(&v) = VT_EMPTY; + hres = pVarRound(&v,0,&vDst); + ok(hres == S_OK && V_VT(&vDst) == VT_I2 && V_I2(&vDst) == 0, + "VarRound: expected 0x0,%d,0 got 0x%lX,%d,%d\n", VT_EMPTY, + hres, V_VT(&vDst), V_I2(&vDst)); + + V_VT(&v) = VT_NULL; + hres = pVarRound(&v,0,&vDst); + ok(hres == S_OK && V_VT(&vDst) == VT_NULL, + "VarRound: expected 0x0,%d got 0x%lX,%d\n", VT_NULL, hres, V_VT(&vDst)); + + /* not yet implemented so no use testing yet + todo_wine { + V_VT(&v) = VT_DECIMAL; + pdec->u.s.sign = DECIMAL_NEG; + pdec->u.s.scale = 0; + pdec->Hi32 = 0; + pdec->u1.s1.Mid32 = 0; + pdec->u1.s1.Lo32 = 1; + hres = pVarRound(&v,0,&vDst); + ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL && + V_DECIMAL(&vDst).u.s.sign == 0, + "VarRound: expected 0x0,%d,0x00, got 0x%lX,%d,%02x\n", VT_DECIMAL, + hres, V_VT(&vDst), V_DECIMAL(&vDst).u.s.sign); + + pdec->u.s.sign = 0; + hres = pVarRound(&v,0,&vDst); + ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL && + V_DECIMAL(&vDst).u.s.sign == DECIMAL_NEG, + "VarRound: expected 0x0,%d,0x7f, got 0x%lX,%d,%02x\n", VT_DECIMAL, + hres, V_VT(&vDst), V_DECIMAL(&vDst).u.s.sign); + } + */ + + V_VT(&v) = VT_CY; + pcy->int64 = 10000; + hres = pVarRound(&v,0,&vDst); + ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == 10000, + "VarRound: VT_CY wrong, hres=0x%lX\n", hres); + +} + START_TEST(vartest) { hOleaut32 = LoadLibraryA("oleaut32.dll"); @@ -2573,4 +2696,5 @@ test_VarFix(); test_VarInt(); test_VarNeg(); + test_VarRound(); }
-
Fabian Cenedese -
Jon Griffiths