| | 1 | | #pragma rtGlobals=3 |
| | 2 | | #pragma rtFunctionErrors=1 |
| | 3 | | #pragma version=1.10 |
| | 4 | | #pragma TextEncoding="UTF-8" |
| | 5 | | #pragma ModuleName=IUTF_Checks |
| | 6 | |
|
| | 7 | | /// @cond HIDDEN_SYMBOL |
| | 8 | |
|
| | 9 | | static Constant NUMTYPE_NAN = 2 |
| | 10 | |
|
| | 11 | | /// @name CountObjects and CountObjectsDFR constant |
| | 12 | | /// @anchor TypeFlags |
| | 13 | | /// @{ |
| | 14 | | static Constant COUNTOBJECTS_WAVES = 1 |
| | 15 | | static Constant COUNTOBJECTS_VAR = 2 |
| | 16 | | static Constant COUNTOBJECTS_STR = 3 |
| | 17 | | static Constant COUNTOBJECTS_DATAFOLDER = 4 |
| | 18 | | /// @} |
| | 19 | |
|
| 0 | 20 | | static Function IsDataFolderEmpty(folder) |
| | 21 | | string folder |
| | 22 | |
|
| 0 | 23 | | return ((CountObjects(folder, COUNTOBJECTS_WAVES) + CountObjects(folder, COUNTOBJECTS_VAR) + CountObjects(folder, COUN |
| 0 | 24 | | End |
| | 25 | |
|
| 21 | 26 | | static Function IsTrue(var) |
| | 27 | | variable var |
| | 28 | |
|
| 21 | 29 | | return (var != 0 && numType(var) != NUMTYPE_NAN) |
| 21 | 30 | | End |
| | 31 | |
|
| 480 | 32 | | static Function IsNullString(str) |
| | 33 | | string &str |
| | 34 | |
|
| 480 | 35 | | return (numtype(strlen(str)) == NUMTYPE_NAN) |
| 480 | 36 | | End |
| | 37 | |
|
| 0 | 38 | | static Function IsEmptyString(str) |
| | 39 | | string &str |
| | 40 | |
|
| 0 | 41 | | return (strlen(str) == 0) |
| 0 | 42 | | End |
| | 43 | |
|
| 0 | 44 | | static Function IsProperString(str) |
| | 45 | | string &str |
| | 46 | |
|
| 0 | 47 | | return !IsEmptyString(str) && !IsNullString(str) |
| 0 | 48 | | End |
| | 49 | |
|
| 330 | 50 | | static Function AreBothVariablesNaN(var1, var2) |
| | 51 | | variable var1, var2 |
| | 52 | |
|
| 330 | 53 | | variable type1 = numType(var1) |
| 330 | 54 | | variable type2 = numType(var2) |
| | 55 | |
|
| 330 | 56 | | return (type1 == type2) && (type1 == NUMTYPE_NAN) |
| 330 | 57 | | End |
| | 58 | |
|
| 330 | 59 | | static Function AreVariablesEqual(var1, var2) |
| | 60 | | variable var1, var2 |
| | 61 | |
|
| 330 | 62 | | return AreBothVariablesNaN(var1, var2) || (var1 == var2) |
| 330 | 63 | | End |
| | 64 | |
|
| 0 | 65 | | static Function IsLessOrEqual(var1, var2) |
| | 66 | | variable var1, var2 |
| | 67 | |
|
| 0 | 68 | | return AreVariablesEqual(var1, var2) || IsLess(var1, var2) |
| 0 | 69 | | End |
| | 70 | |
|
| 0 | 71 | | static Function IsLess(var1, var2) |
| | 72 | | variable var1, var2 |
| | 73 | |
|
| 0 | 74 | | return var1 < var2 |
| 0 | 75 | | End |
| | 76 | |
|
| | 77 | | #if IgorVersion() >= 7.00 |
| | 78 | |
|
| 0 | 79 | | static Function AreINT64Equal(int64 var1, int64 var2) |
| 0 | 80 | | int64 IsEqual |
| | 81 | |
|
| 0 | 82 | | IsEqual = var1 == var2 |
| 0 | 83 | | return IsEqual |
| 0 | 84 | | End |
| | 85 | |
|
| 0 | 86 | | static Function AreUINT64Equal(uint64 var1, uint64 var2) |
| 0 | 87 | | uint64 IsEqual |
| | 88 | |
|
| 0 | 89 | | IsEqual = var1 == var2 |
| 0 | 90 | | return IsEqual |
| 0 | 91 | | End |
| | 92 | |
|
| | 93 | | #endif |
| | 94 | |
|
| 0 | 95 | | static Function IsVariableSmall(var, tol) |
| | 96 | | variable var |
| | 97 | | variable tol |
| | 98 | |
|
| 0 | 99 | | return (abs(var) <= abs(tol)) |
| 0 | 100 | | End |
| | 101 | |
|
| | 102 | | #if IgorVersion() >= 7.0 |
| | 103 | |
|
| 0 | 104 | | static Function IsINT64Small(int64 var, int64 tol) |
| 0 | 105 | | int64 comparison |
| | 106 | |
|
| 0 | 107 | | comparison = tol < 0 |
| 0 | 108 | | if(comparison) |
| 0 | 109 | | tol = -tol |
| 0 | 110 | | endif |
| | 111 | |
|
| 0 | 112 | | comparison = var < 0 |
| 0 | 113 | | if(comparison) |
| 0 | 114 | | var = -var |
| 0 | 115 | | endif |
| | 116 | |
|
| 0 | 117 | | comparison = var < tol |
| 0 | 118 | | return comparison |
| 0 | 119 | | End |
| | 120 | |
|
| 0 | 121 | | static Function IsUINT64Small(uint64 var, uint64 tol) |
| 0 | 122 | | uint64 comparison |
| | 123 | |
|
| 0 | 124 | | comparison = var < tol |
| | 125 | |
|
| 0 | 126 | | return comparison |
| 0 | 127 | | End |
| | 128 | |
|
| | 129 | | #endif |
| | 130 | |
|
| 0 | 131 | | static Function AreVariablesClose(var1, var2, tol, strong) |
| | 132 | | variable var1, var2 |
| | 133 | | variable tol |
| | 134 | | variable strong |
| | 135 | |
|
| 0 | 136 | | if(var1 == 0 || var2 == 0) |
| 0 | 137 | | return IsVariableSmall(var1 - var2, tol) |
| 0 | 138 | | endif |
| | 139 | |
|
| 0 | 140 | | strong = !!strong |
| | 141 | |
|
| 0 | 142 | | variable diff = abs(var1 - var2) |
| 0 | 143 | | variable d1 = diff / abs(var1) |
| 0 | 144 | | variable d2 = diff / abs(var2) |
| | 145 | |
|
| 0 | 146 | | // printf "d1 %.15g, d2 %.15g, d1 - d2 %.15g, strong %d, weak %d\r", d1, d2, d1 - d2, (d1 <= tol && d2 <= tol), (d1 <= |
| | 147 | |
|
| 0 | 148 | | if(strong) |
| 0 | 149 | | return (d1 <= tol && d2 <= tol) |
| 0 | 150 | | else |
| 0 | 151 | | return (d1 <= tol || d2 <= tol) |
| 0 | 152 | | endif |
| 0 | 153 | | End |
| | 154 | |
|
| | 155 | | #if IgorVersion() >= 7.0 |
| | 156 | |
|
| 0 | 157 | | static Function AreINT64Close(int64 var1, int64 var2, int64 tol) |
| 0 | 158 | | int64 temp, diff, comparison |
| | 159 | |
|
| 0 | 160 | | comparison = tol < 0 |
| 0 | 161 | | if(comparison) |
| 0 | 162 | | tol = -tol |
| 0 | 163 | | endif |
| | 164 | |
|
| 0 | 165 | | comparison = var2 > var1 |
| 0 | 166 | | if(comparison) |
| 0 | 167 | | temp = var1 |
| 0 | 168 | | var1 = var2 |
| 0 | 169 | | var2 = temp |
| 0 | 170 | | endif |
| | 171 | |
|
| 0 | 172 | | diff = var1 - var2 |
| 0 | 173 | | comparison = diff < tol |
| | 174 | |
|
| 0 | 175 | | return comparison |
| 0 | 176 | | End |
| | 177 | |
|
| 0 | 178 | | static Function AreUINT64Close(uint64 var1, uint64 var2, uint64 tol) |
| 0 | 179 | | uint64 temp, diff, comparison |
| | 180 | |
|
| 0 | 181 | | comparison = var2 > var1 |
| 0 | 182 | | if(comparison) |
| 0 | 183 | | temp = var1 |
| 0 | 184 | | var1 = var2 |
| 0 | 185 | | var2 = temp |
| 0 | 186 | | endif |
| | 187 | |
|
| 0 | 188 | | diff = var1 - var2 |
| 0 | 189 | | comparison = diff < tol |
| | 190 | |
|
| 0 | 191 | | return comparison |
| 0 | 192 | | End |
| | 193 | |
|
| | 194 | | #endif |
| | 195 | |
|
| | 196 | | /// @return 1 if both strings are equal and zero otherwise |
| 160 | 197 | | static Function AreStringsEqual(str1, str2, case_sensitive) |
| | 198 | | string &str1, &str2 |
| | 199 | | variable case_sensitive |
| | 200 | |
|
| 160 | 201 | | case_sensitive = !!case_sensitive |
| | 202 | |
|
| 160 | 203 | | if(IsNullString(str1) && IsNullString(str2)) |
| 0 | 204 | | return 1 |
| 160 | 205 | | elseif(IsNullString(str1) || IsNullString(str2)) |
| 0 | 206 | | return 0 |
| 160 | 207 | | else |
| 160 | 208 | | return (cmpstr(str1, str2, case_sensitive) == 0) |
| 0 | 209 | | endif |
| 160 | 210 | | End |
| | 211 | |
|
| 0 | 212 | | static Function AreWavesEqual(wv1, wv2, mode, tol, detailedMsg) |
| | 213 | | WAVE/Z wv1, wv2 |
| | 214 | | variable mode, tol |
| | 215 | | string &detailedMsg |
| | 216 | |
|
| 0 | 217 | | string waveDataMsg = "" |
| 0 | 218 | | string dimLabelMsg = "" |
| 0 | 219 | | variable result, err |
| | 220 | |
|
| 0 | 221 | | if(mode == WAVE_DATA) |
| 0 | 222 | | if(!numpnts(wv1) || !numpnts(wv2)) |
| 0 | 223 | | result = !numpnts(wv1) && !numpnts(wv2) |
| 0 | 224 | | elseif(WaveType(wv1, 1) != WaveType(wv2, 1)) |
| 0 | 225 | | detailedMsg = "The base wave types are different, WAVE_DATA can not be compared." |
| 0 | 226 | | return 0 |
| 0 | 227 | | else |
| 0 | 228 | | result = EqualWaves(wv1, wv2, mode, tol) == 1 |
| 0 | 229 | | endif |
| 0 | 230 | | else |
| 0 | 231 | | result = EqualWaves(wv1, wv2, mode, tol) == 1 |
| 0 | 232 | | endif |
| | 233 | |
|
| 0 | 234 | | if(!result) |
| 0 | 235 | | switch(mode) |
| 0 | 236 | | case WAVE_DATA: |
| 0 | 237 | | waveDataMsg = IUTF_Utils#DetermineWaveDataDifference(wv1, wv2, tol) |
| 0 | 238 | | case WAVE_DATA_TYPE: |
| 0 | 239 | | case WAVE_SCALING: |
| 0 | 240 | | case DATA_UNITS: |
| 0 | 241 | | case DIMENSION_UNITS: |
| 0 | 242 | | case WAVE_NOTE: |
| 0 | 243 | | case WAVE_LOCK_STATE: |
| 0 | 244 | | case DATA_FULL_SCALE: |
| 0 | 245 | | case DIMENSION_SIZES: |
| 0 | 246 | | // FIXME add detailed msg generation functions |
| 0 | 247 | | break |
| 0 | 248 | | case DIMENSION_LABELS: |
| 0 | 249 | | // work around buggy EqualWaves versions which detect some |
| 0 | 250 | | // waves as differing but they are not in reality |
| | 251 | | #if IgorVersion() >= 9.0 |
| 0 | 252 | | GenerateDimLabelDifference(wv1, wv2, dimLabelMsg) |
| | 253 | | #elif IgorVersion() >= 8.0 |
| | 254 | | #if NumberByKey("BUILD", IgorInfo(0)) >= 33425 |
| 0 | 255 | | GenerateDimLabelDifference(wv1, wv2, dimLabelMsg) |
| | 256 | | #else // old IP8 |
| 0 | 257 | | result = GenerateDimLabelDifference(wv1, wv2, dimLabelMsg) |
| | 258 | | #endif |
| | 259 | | #else // IP7 and older |
| 0 | 260 | | result = GenerateDimLabelDifference(wv1, wv2, dimLabelMsg) |
| | 261 | | #endif |
| 0 | 262 | | break |
| 0 | 263 | | endswitch |
| | 264 | |
|
| 0 | 265 | | detailedMsg = waveDataMsg |
| 0 | 266 | | if(!IUTF_Utils#IsEmpty(dimLabelMsg)) |
| 0 | 267 | | detailedMsg += "\r" + dimLabelMsg |
| 0 | 268 | | endif |
| 0 | 269 | | else |
| 0 | 270 | | detailedMsg = "" |
| 0 | 271 | | endif |
| | 272 | |
|
| 0 | 273 | | return result |
| 0 | 274 | | End |
| | 275 | |
|
| 0 | 276 | | static Function AddIfFlagSet(var, flag, flagString, str) |
| | 277 | | variable var, flag |
| | 278 | | string flagString |
| | 279 | | string &str |
| | 280 | |
|
| 0 | 281 | | if((var & flag) == flag) |
| 0 | 282 | | str = flagString + ", " + str |
| 0 | 283 | | endif |
| 0 | 284 | | End |
| | 285 | |
|
| 0 | 286 | | static Function GetWaveMajorType(wv) |
| | 287 | | WAVE/Z wv |
| | 288 | |
|
| 0 | 289 | | variable type = 0 |
| 0 | 290 | | variable type2 = WaveType(wv, 2) |
| 0 | 291 | | variable type1 = WaveType(wv, 1) |
| | 292 | |
|
| 0 | 293 | | if(type1 > 0 && type1 <= 4) |
| 0 | 294 | | type = type | 2^(type1 - 1) |
| 0 | 295 | | endif |
| | 296 | |
|
| 0 | 297 | | if(type2 > 0 && type2 <= 2) |
| 0 | 298 | | type = type | 2^(type2 + 3) |
| 0 | 299 | | endif |
| | 300 | |
|
| 0 | 301 | | if((type1 == 0 && type2 == 0) || !WaveExists(wv)) |
| 0 | 302 | | type = NULL_WAVE |
| 0 | 303 | | endif |
| | 304 | |
|
| 0 | 305 | | return type |
| 0 | 306 | | End |
| | 307 | |
|
| 0 | 308 | | static Function HasWaveMajorType(wv, majorType) |
| | 309 | | WAVE/Z wv |
| | 310 | | variable majorType |
| | 311 | |
|
| 0 | 312 | | return (GetWaveMajorType(wv) & majorType) == majorType |
| 0 | 313 | | End |
| | 314 | |
|
| 0 | 315 | | static Function/S GetWaveMajorTypeString(type) |
| | 316 | | variable type |
| | 317 | |
|
| 0 | 318 | | string str = "" |
| | 319 | |
|
| 0 | 320 | | if((type & NULL_WAVE) == NULL_WAVE) |
| 0 | 321 | | return "NULL_WAVE" |
| 0 | 322 | | endif |
| 0 | 323 | | AddIfFlagSet(type, NUMERIC_WAVE, "NUMERIC_WAVE", str) |
| 0 | 324 | | AddIfFlagSet(type, TEXT_WAVE, "TEXT_WAVE", str) |
| 0 | 325 | | AddIfFlagSet(type, DATAFOLDER_WAVE, "DATAFOLDER_WAVE", str) |
| 0 | 326 | | AddIfFlagSet(type, WAVE_WAVE, "WAVE_WAVE", str) |
| 0 | 327 | | AddIfFlagSet(type, NORMAL_WAVE, "NORMAL_WAVE", str) |
| 0 | 328 | | AddIfFlagSet(type, FREE_WAVE, "FREE_WAVE", str) |
| | 329 | |
|
| 0 | 330 | | if(!CmpStr(str, "")) |
| 0 | 331 | | return num2str(type) |
| 0 | 332 | | endif |
| | 333 | |
|
| 0 | 334 | | return RemoveEnding(str, ", ") |
| 0 | 335 | | End |
| | 336 | |
|
| 0 | 337 | | static Function GetWaveMinorType(wv) |
| | 338 | | WAVE/Z wv |
| | 339 | |
|
| 0 | 340 | | variable type |
| | 341 | |
|
| 0 | 342 | | if(!WaveExists(wv)) |
| 0 | 343 | | return NULL_WAVE |
| 0 | 344 | | endif |
| | 345 | |
|
| 0 | 346 | | type = WaveType(wv, 0) |
| | 347 | |
|
| 0 | 348 | | if(type == 0) |
| 0 | 349 | | type = NON_NUMERIC_WAVE |
| 0 | 350 | | endif |
| | 351 | |
|
| 0 | 352 | | return type |
| 0 | 353 | | End |
| | 354 | |
|
| 0 | 355 | | static Function HasWaveMinorType(wv, minorType) |
| | 356 | | WAVE/Z wv |
| | 357 | | variable minorType |
| | 358 | |
|
| 0 | 359 | | return (GetWaveMinorType(wv) & minorType) == minorType |
| 0 | 360 | | End |
| | 361 | |
|
| 0 | 362 | | static Function/S GetWaveMinorTypeString(type) |
| | 363 | | variable type |
| | 364 | |
|
| 0 | 365 | | string str = "" |
| | 366 | |
|
| 0 | 367 | | if((type & NULL_WAVE) == NULL_WAVE) |
| 0 | 368 | | return "NULL_WAVE" |
| 0 | 369 | | endif |
| 0 | 370 | | AddIfFlagSet(type, NON_NUMERIC_WAVE, "NON_NUMERIC_WAVE", str) |
| 0 | 371 | | AddIfFlagSet(type, COMPLEX_WAVE, "COMPLEX_WAVE", str) |
| 0 | 372 | | AddIfFlagSet(type, FLOAT_WAVE, "FLOAT_WAVE", str) |
| 0 | 373 | | AddIfFlagSet(type, DOUBLE_WAVE, "DOUBLE_WAVE", str) |
| 0 | 374 | | AddIfFlagSet(type, INT8_WAVE, "INT8_WAVE", str) |
| 0 | 375 | | AddIfFlagSet(type, INT16_WAVE, "INT16_WAVE", str) |
| 0 | 376 | | AddIfFlagSet(type, INT32_WAVE, "INT32_WAVE", str) |
| 0 | 377 | | AddIfFlagSet(type, INT64_WAVE, "INT64_WAVE", str) |
| 0 | 378 | | AddIfFlagSet(type, UNSIGNED_WAVE, "UNSIGNED_WAVE", str) |
| | 379 | |
|
| 0 | 380 | | if(!CmpStr(str, "")) |
| 0 | 381 | | return num2str(type) |
| 0 | 382 | | endif |
| | 383 | |
|
| 0 | 384 | | return RemoveEnding(str, ", ") |
| 0 | 385 | | End |
| | 386 | |
|
| 0 | 387 | | static Function HasRTE(code) |
| | 388 | | variable code |
| | 389 | |
|
| 0 | 390 | | variable rte = GetRTError(0) |
| | 391 | |
|
| 0 | 392 | | return rte == code |
| 0 | 393 | | End |
| | 394 | |
|
| 0 | 395 | | static Function HasAnyRTE() |
| 0 | 396 | | variable code |
| | 397 | |
|
| 0 | 398 | | variable rte = GetRTError(0) |
| | 399 | |
|
| 0 | 400 | | return !!rte |
| 0 | 401 | | End |
| | 402 | |
|
| | 403 | | /// @endcond // HIDDEN_SYMBOL |