00001
00002
00003
00004
00005
00006
00007 #include "strctbse.h"
00008 #include "datahndl.h"
00009 #include "arraybse.h"
00010 #include "range.h"
00011 #include "camtype.h"
00012 #include "under.h"
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027 #ifndef _CAMDOUBLEARRAY_
00028 #define _CAMDOUBLEARRAY_
00029
00030 #include "mvaimpexp.h"
00031
00032 class __IMPEXP__ CAMdoubleArray : public CAMarrayBase
00033 {
00034
00035 public :
00036
00037
00038
00039
00040 CAMdoubleArray():CAMarrayBase(CAMType::typeDouble){};
00041 CAMdoubleArray(const CAMdoubleArray& A):CAMarrayBase(*((CAMarrayBase*)&A)){};
00042 CAMdoubleArray(const CAMarrayBase& A):CAMarrayBase(A){};
00043 CAMdoubleArray(long n):CAMarrayBase(CAMType::typeDouble, n){};
00044 CAMdoubleArray(const CAMrange& R1, const CAMrange& R2 = CAMnullRange,
00045 const CAMrange& R3 = CAMnullRange, const CAMrange&R4 = CAMnullRange,
00046 const CAMrange& R5 = CAMnullRange, const CAMrange&R6 = CAMnullRange,
00047 const CAMrange& R7 = CAMnullRange) :
00048 CAMarrayBase(CAMType::typeDouble,R1, R2, R3, R4, R5, R6, R7){ };
00049
00050
00051
00052 void operator = (const CAMdoubleArray& A)
00053 {CAMarrayBase* basePtr = this; const CAMarrayBase* AbasePtr =
00054 (CAMarrayBase*)&A; basePtr->operator=(*AbasePtr);};
00055 void operator =( const CAMarrayBase& A)
00056 {CAMarrayBase* basePtr = this; basePtr->operator=(A);};
00057 void operator = (double value)
00058 {CAMarrayBase* basePtr = this; basePtr->operator=(value);};
00059
00060
00061
00062 void initialize()
00063 {CAMarrayBase* basePtr = this; basePtr->initialize(CAMType::typeDouble);};
00064 void initialize(const CAMdoubleArray& A)
00065 {CAMarrayBase* basePtr = this; basePtr->initialize(A);};
00066 void initialize(const CAMarrayBase& A)
00067 {CAMarrayBase* basePtr = this; basePtr->initialize(A);};
00068 void initialize(long n)
00069 {CAMarrayBase* basePtr = this; basePtr->initialize(CAMType::typeDouble, n);};
00070 void initialize(const CAMrange& R1, const CAMrange& R2 = CAMnullRange,
00071 const CAMrange& R3 = CAMnullRange, const CAMrange&R4 = CAMnullRange,
00072 const CAMrange& R5 = CAMnullRange, const CAMrange&R6 = CAMnullRange,
00073 const CAMrange& R7 = CAMnullRange){CAMarrayBase* basePtr = this;
00074 basePtr->initialize(CAMType::typeDouble,R1, R2, R3, R4, R5, R6, R7);};
00075
00076
00077
00078 inline double& operator()(long i1)
00079 {
00080 #ifndef _NO_BOUNDS_CHECK_
00081 CAMarrayBase::indexCheck(Structure,i1);
00082 #endif
00083 long* beginPtr = Structure.indexBeginBase.getDataPointer();
00084
00085 double* dataPtr = (double*)DataP->dataPointer;
00086 long offset = (i1 - *(beginPtr));
00087 return *(dataPtr + offset);
00088 };
00089 inline double& operator()(long i1, long i2)
00090 {
00091 #ifndef _NO_BOUNDS_CHECK_
00092 CAMarrayBase::indexCheck(Structure,i1,i2);
00093 #endif
00094 long* beginPtr = Structure.indexBeginBase.getDataPointer();
00095 long* endPtr = Structure.indexEndBase.getDataPointer();
00096
00097 double* dataPtr = (double*)DataP->dataPointer;
00098
00099 long offset =
00100 (i1 - *(beginPtr)) +
00101 ((*endPtr - *beginPtr) + 1)*(i2 - *(beginPtr +1));
00102
00103 return (*(dataPtr + offset));
00104 };
00105 inline double& operator()(long i1, long i2, long i3)
00106 {
00107 #ifndef _NO_BOUNDS_CHECK_
00108 CAMarrayBase::indexCheck(Structure,i1,i2,i3);
00109 #endif
00110 long* beginPtr = Structure.indexBeginBase.getDataPointer();
00111 long* endPtr = Structure.indexEndBase.getDataPointer();
00112
00113 double* dataPtr = (double*)DataP->dataPointer;
00114 long offset = (i1 - *(beginPtr)) +
00115 ((*endPtr - *beginPtr) + 1)*
00116 ((i2 - *(beginPtr +1)) +
00117 ((*(endPtr +1) - *(beginPtr +1)) + 1)*
00118 (i3 - *(beginPtr + 2)));
00119 return (*(dataPtr + offset));
00120 };
00121 inline double& operator()(long i1, long i2, long i3, long i4)
00122 {
00123 #ifndef _NO_BOUNDS_CHECK_
00124 CAMarrayBase::indexCheck(Structure,i1,i2,i3,i4);
00125 #endif
00126 long* beginPtr = Structure.indexBeginBase.getDataPointer();
00127 long* endPtr = Structure.indexEndBase.getDataPointer();
00128
00129 double* dataPtr = (double*)DataP->dataPointer;
00130 long offset = (i1 - *(beginPtr)) +
00131 ((*endPtr - *beginPtr) + 1)*
00132 ( (i2 - *(beginPtr +1)) +
00133 ((*(endPtr +1) - *(beginPtr +1)) + 1)*
00134 ( (i3 - *(beginPtr + 2)) +
00135 ((*(endPtr +2) - *(beginPtr +2)) + 1)*(i4 - *(beginPtr + 3))));
00136 return (*(dataPtr + offset));
00137 };
00138 inline double& operator()(long i1, long i2, long i3, long i4, long i5)
00139 {
00140 #ifndef _NO_BOUNDS_CHECK_
00141 CAMarrayBase::indexCheck(Structure,i1,i2,i3,i4,i5);
00142 #endif
00143 long* beginPtr = Structure.indexBeginBase.getDataPointer();
00144 long* endPtr = Structure.indexEndBase.getDataPointer();
00145
00146 double* dataPtr = (double*)DataP->dataPointer;
00147 long offset = (i1 - *(beginPtr)) +
00148 ((*endPtr - *beginPtr) + 1)*
00149 ((i2 - *(beginPtr +1)) +
00150 ((*(endPtr +1) - *(beginPtr +1)) + 1)*
00151 ((i3 - *(beginPtr + 2)) +
00152 ((*(endPtr +2) - *(beginPtr +2)) + 1)*
00153 ((i4 - *(beginPtr + 3)) +
00154 ((*(endPtr +3) - *(beginPtr +3)) + 1)*(i5 - *(beginPtr + 4)))));
00155 return (*(dataPtr + offset));
00156 };
00157 inline double& operator()(long i1, long i2, long i3, long i4, long i5, long i6)
00158 {
00159 #ifndef _NO_BOUNDS_CHECK_
00160 CAMarrayBase::indexCheck(Structure,i1,i2,i3,i4,i5,i6);
00161 #endif
00162 long* beginPtr = Structure.indexBeginBase.getDataPointer();
00163 long* endPtr = Structure.indexEndBase.getDataPointer();
00164
00165 double* dataPtr = (double*)DataP->dataPointer;
00166 long offset = (i1 - *(beginPtr)) +
00167 ((*endPtr - *beginPtr) + 1)*
00168 ((i2 - *(beginPtr +1)) +
00169 ((*(endPtr +1) - *(beginPtr +1)) + 1)*
00170 ((i3 - *(beginPtr + 2)) +
00171 ((*(endPtr +2) - *(beginPtr +2)) + 1)*
00172 ((i4 - *(beginPtr + 3)) +
00173 ((*(endPtr +3) - *(beginPtr +3)) + 1)*
00174 ((i5 - *(beginPtr + 4)) +
00175 ((*(endPtr +4) - *(beginPtr +4)) + 1)*(i6 - *(beginPtr + 5))))));
00176 return (*(dataPtr + offset));
00177 };
00178 inline double& operator()(long i1, long i2, long i3, long i4, long i5, long i6, long i7)
00179 {
00180 #ifndef _NO_BOUNDS_CHECK_
00181 CAMarrayBase::indexCheck(Structure,i1,i2,i3,i4,i5,i6,i7);
00182 #endif
00183 long* beginPtr = Structure.indexBeginBase.getDataPointer();
00184 long* endPtr = Structure.indexEndBase.getDataPointer();
00185
00186 double* dataPtr = (double*)DataP->dataPointer;
00187 long offset = (i1 - *(beginPtr)) +
00188 ((*endPtr - *beginPtr) + 1)*
00189 ((i2 - *(beginPtr +1)) +
00190 ((*(endPtr +1) - *(beginPtr +1)) + 1)*
00191 ((i3 - *(beginPtr + 2)) +
00192 ((*(endPtr +2) - *(beginPtr +2)) + 1)*
00193 ((i4 - *(beginPtr + 3)) +
00194 ((*(endPtr +3) - *(beginPtr +3)) + 1)*
00195 ((i5 - *(beginPtr + 4)) +
00196 ((*(endPtr +4) - *(beginPtr +4)) + 1)*
00197 ((i6 - *(beginPtr + 5)) +
00198 ((*(endPtr +5) - *(beginPtr +5)) + 1)*(i7 - *(beginPtr + 6)))))));
00199 return (*(dataPtr + offset));
00200 };
00201 inline const double& operator()(long i1) const
00202 {
00203 #ifndef _NO_BOUNDS_CHECK_
00204 CAMarrayBase::indexCheck(Structure,i1);
00205 #endif
00206 const long* beginPtr = Structure.indexBeginBase.getDataPointer();
00207 double* dataPtr = (double*)DataP->dataPointer;
00208 long offset = (i1 - *(beginPtr));
00209 return (*(dataPtr + offset));
00210 };
00211 inline const double& operator()(long i1, long i2) const
00212 {
00213 #ifndef _NO_BOUNDS_CHECK_
00214 CAMarrayBase::indexCheck(Structure,i1,i2);
00215 #endif
00216 const long* beginPtr = Structure.indexBeginBase.getDataPointer();
00217 const long* endPtr = Structure.indexEndBase.getDataPointer();
00218
00219 double* dataPtr = (double*)DataP->dataPointer;
00220
00221 long offset =
00222 (i1 - *(beginPtr)) +
00223 ((*endPtr - *beginPtr) + 1)*(i2 - *(beginPtr +1));
00224
00225 return (*(dataPtr + offset));
00226 };
00227 inline const double& operator()(long i1, long i2, long i3) const
00228 {
00229 #ifndef _NO_BOUNDS_CHECK_
00230 CAMarrayBase::indexCheck(Structure,i1,i2,i3);
00231 #endif
00232 const long* beginPtr = Structure.indexBeginBase.getDataPointer();
00233 const long* endPtr = Structure.indexEndBase.getDataPointer();
00234
00235 double* dataPtr = (double*)DataP->dataPointer;
00236 long offset = (i1 - *(beginPtr)) +
00237 ((*endPtr - *beginPtr) + 1)*
00238 ((i2 - *(beginPtr +1)) +
00239 ((*(endPtr +1) - *(beginPtr +1)) + 1)*
00240 (i3 - *(beginPtr + 2)));
00241 return (*(dataPtr + offset));
00242 };
00243 inline const double& operator()(long i1, long i2, long i3, long i4) const
00244 {
00245 #ifndef _NO_BOUNDS_CHECK_
00246 CAMarrayBase::indexCheck(Structure,i1,i2,i3,i4);
00247 #endif
00248 const long* beginPtr = Structure.indexBeginBase.getDataPointer();
00249 const long* endPtr = Structure.indexEndBase.getDataPointer();
00250
00251 double* dataPtr = (double*)DataP->dataPointer;
00252 long offset = (i1 - *(beginPtr)) +
00253 ((*endPtr - *beginPtr) + 1)*
00254 ( (i2 - *(beginPtr +1)) +
00255 ((*(endPtr +1) - *(beginPtr +1)) + 1)*
00256 ( (i3 - *(beginPtr + 2)) +
00257 ((*(endPtr +2) - *(beginPtr +2)) + 1)*(i4 - *(beginPtr + 3))));
00258 return (*(dataPtr + offset));
00259 };
00260 inline const double& operator()(long i1, long i2, long i3, long i4, long i5) const
00261 {
00262 #ifndef _NO_BOUNDS_CHECK_
00263 CAMarrayBase::indexCheck(Structure,i1,i2,i3,i4,i5);
00264 #endif
00265 const long* beginPtr = Structure.indexBeginBase.getDataPointer();
00266 const long* endPtr = Structure.indexEndBase.getDataPointer();
00267
00268 double* dataPtr = (double*)DataP->dataPointer;
00269 long offset = (i1 - *(beginPtr)) +
00270 ((*endPtr - *beginPtr) + 1)*
00271 ((i2 - *(beginPtr +1)) +
00272 ((*(endPtr +1) - *(beginPtr +1)) + 1)*
00273 ((i3 - *(beginPtr + 2)) +
00274 ((*(endPtr +2) - *(beginPtr +2)) + 1)*
00275 ((i4 - *(beginPtr + 3)) +
00276 ((*(endPtr +3) - *(beginPtr +3)) + 1)*(i5 - *(beginPtr + 4)))));
00277 return (*(dataPtr + offset));
00278 };
00279 inline const double& operator()(long i1, long i2, long i3, long i4, long i5, long i6) const
00280 {
00281 #ifndef _NO_BOUNDS_CHECK_
00282 CAMarrayBase::indexCheck(Structure,i1,i2,i3,i4,i5,i6);
00283 #endif
00284 const long* beginPtr = Structure.indexBeginBase.getDataPointer();
00285 const long* endPtr = Structure.indexEndBase.getDataPointer();
00286
00287 double* dataPtr = (double*)DataP->dataPointer;
00288 long offset = (i1 - *(beginPtr)) +
00289 ((*endPtr - *beginPtr) + 1)*
00290 ((i2 - *(beginPtr +1)) +
00291 ((*(endPtr +1) - *(beginPtr +1)) + 1)*
00292 ((i3 - *(beginPtr + 2)) +
00293 ((*(endPtr +2) - *(beginPtr +2)) + 1)*
00294 ((i4 - *(beginPtr + 3)) +
00295 ((*(endPtr +3) - *(beginPtr +3)) + 1)*
00296 ((i5 - *(beginPtr + 4)) +
00297 ((*(endPtr +4) - *(beginPtr +4)) + 1)*(i6 - *(beginPtr + 5))))));
00298 return (*(dataPtr + offset));
00299 };
00300 inline const double& operator()(long i1, long i2, long i3, long i4, long i5, long i6, long i7) const
00301 {
00302 #ifndef _NO_BOUNDS_CHECK_
00303 CAMarrayBase::indexCheck(Structure,i1,i2,i3,i4,i5,i6,i7);
00304 #endif
00305 const long* beginPtr = Structure.indexBeginBase.getDataPointer();
00306 const long* endPtr = Structure.indexEndBase.getDataPointer();
00307
00308 double* dataPtr = (double*)DataP->dataPointer;
00309 long offset = (i1 - *(beginPtr)) +
00310 ((*endPtr - *beginPtr) + 1)*
00311 ((i2 - *(beginPtr +1)) +
00312 ((*(endPtr +1) - *(beginPtr +1)) + 1)*
00313 ((i3 - *(beginPtr + 2)) +
00314 ((*(endPtr +2) - *(beginPtr +2)) + 1)*
00315 ((i4 - *(beginPtr + 3)) +
00316 ((*(endPtr +3) - *(beginPtr +3)) + 1)*
00317 ((i5 - *(beginPtr + 4)) +
00318 ((*(endPtr +4) - *(beginPtr +4)) + 1)*
00319 ((i6 - *(beginPtr + 5)) +
00320 ((*(endPtr +5) - *(beginPtr +5)) + 1)*(i7 - *(beginPtr + 6)))))));
00321 return (*(dataPtr + offset));
00322 };
00323 CAMdoubleArray operator() (const CAMrange& R1)
00324 {
00325 CAMstructureBase Rstructure(Structure);
00326 Rstructure.setStructureSubset(R1);
00327 CAMdoubleArray A;
00328 A.Structure.initialize(Rstructure);
00329 A.DataP = DataP;
00330 A.DataP->incrementReferenceCount();
00331 A.DataP->incrementReferenceCount();
00332 A.referenceFlag = 1;
00333 return A;
00334 };
00335 const CAMdoubleArray operator()(const CAMrange& R1) const
00336 {
00337 CAMstructureBase Rstructure(Structure);
00338 Rstructure.setStructureSubset(R1);
00339 CAMdoubleArray A;
00340 A.Structure.initialize(Rstructure);
00341 A.DataP = DataP;
00342 A.DataP->incrementReferenceCount();
00343 A.DataP->incrementReferenceCount();
00344 A.referenceFlag = 1;
00345 return A;
00346 };
00347 const CAMdoubleArray operator()(const CAMrange& R1, const CAMrange& R2) const
00348 {
00349 CAMstructureBase Rstructure(Structure);
00350 Rstructure.setStructureSubset(R1,R2);
00351 CAMdoubleArray A;
00352 A.Structure.initialize(Rstructure);
00353 A.DataP = DataP;
00354 A.DataP->incrementReferenceCount();
00355 A.DataP->incrementReferenceCount();
00356 A.referenceFlag = 1;
00357 return A;
00358 };
00359 CAMdoubleArray operator() (const CAMrange& R1, const CAMrange& R2)
00360 {
00361 CAMstructureBase Rstructure(Structure);
00362 Rstructure.setStructureSubset(R1,R2);
00363 CAMdoubleArray A;
00364 A.Structure.initialize(Rstructure);
00365 A.DataP = DataP;
00366 A.DataP->incrementReferenceCount();
00367 A.DataP->incrementReferenceCount();
00368 A.referenceFlag = 1;
00369 return A;
00370 };
00371 const CAMdoubleArray operator()(const CAMrange& R1, const CAMrange& R2,
00372 const CAMrange& R3) const
00373 {
00374 CAMstructureBase Rstructure(Structure);
00375 Rstructure.setStructureSubset(R1,R2,R3);
00376 CAMdoubleArray A;
00377 A.Structure.initialize(Rstructure);
00378 A.DataP = DataP;
00379 A.DataP->incrementReferenceCount();
00380 A.DataP->incrementReferenceCount();
00381 A.referenceFlag = 1;
00382 return A;
00383 };
00384 CAMdoubleArray operator() (const CAMrange& R1, const CAMrange& R2,
00385 const CAMrange& R3)
00386 {
00387 CAMstructureBase Rstructure(Structure);
00388 Rstructure.setStructureSubset(R1,R2, R3);
00389 CAMdoubleArray A;
00390 A.Structure.initialize(Rstructure);
00391 A.DataP = DataP;
00392 A.DataP->incrementReferenceCount();
00393 A.DataP->incrementReferenceCount();
00394 A.referenceFlag = 1;
00395 return A;
00396 };
00397 const CAMdoubleArray operator()(const CAMrange& R1, const CAMrange& R2,
00398 const CAMrange& R3, const CAMrange& R4) const
00399 {
00400 CAMstructureBase Rstructure(Structure);
00401 Rstructure.setStructureSubset(R1,R2,R3,R4);
00402 CAMdoubleArray A;
00403 A.Structure.initialize(Rstructure);
00404 A.DataP = DataP;
00405 A.DataP->incrementReferenceCount();
00406 A.DataP->incrementReferenceCount();
00407 A.referenceFlag = 1;
00408 return A;
00409 };
00410 CAMdoubleArray operator() (const CAMrange& R1, const CAMrange& R2,
00411 const CAMrange& R3, const CAMrange& R4)
00412 {
00413 CAMstructureBase Rstructure(Structure);
00414 Rstructure.setStructureSubset(R1,R2, R3, R4);
00415 CAMdoubleArray A;
00416 A.Structure.initialize(Rstructure);
00417 A.DataP = DataP;
00418 A.DataP->incrementReferenceCount();
00419 A.DataP->incrementReferenceCount();
00420 A.referenceFlag = 1;
00421 return A;
00422 };
00423 const CAMdoubleArray operator()(const CAMrange& R1, const CAMrange& R2,
00424 const CAMrange& R3, const CAMrange& R4, const CAMrange& R5) const
00425 {
00426 CAMstructureBase Rstructure(Structure);
00427 Rstructure.setStructureSubset(R1,R2,R3,R4, R5);
00428 CAMdoubleArray A;
00429 A.Structure.initialize(Rstructure);
00430 A.DataP = DataP;
00431 A.DataP->incrementReferenceCount();
00432 A.DataP->incrementReferenceCount();
00433 A.referenceFlag = 1;
00434 return A;
00435 };
00436 CAMdoubleArray operator() (const CAMrange& R1, const CAMrange& R2,
00437 const CAMrange& R3, const CAMrange& R4, const CAMrange& R5)
00438 {
00439 CAMstructureBase Rstructure(Structure);
00440 Rstructure.setStructureSubset(R1,R2, R3, R4, R5);
00441 CAMdoubleArray A;
00442 A.Structure.initialize(Rstructure);
00443 A.DataP = DataP;
00444 A.DataP->incrementReferenceCount();
00445 A.DataP->incrementReferenceCount();
00446 A.referenceFlag = 1;
00447 return A;
00448 };
00449 CAMdoubleArray operator() (const CAMrange& R1, const CAMrange& R2,
00450 const CAMrange& R3, const CAMrange& R4, const CAMrange& R5,
00451 const CAMrange& R6)
00452 {
00453 CAMstructureBase Rstructure(Structure);
00454 Rstructure.setStructureSubset(R1,R2, R3, R4, R5, R6);
00455 CAMdoubleArray A;
00456 A.Structure.initialize(Rstructure);
00457 A.DataP = DataP;
00458 A.DataP->incrementReferenceCount();
00459 A.DataP->incrementReferenceCount();
00460 A.referenceFlag = 1;
00461 return A;
00462 };
00463 const CAMdoubleArray operator()(const CAMrange& R1, const CAMrange& R2,
00464 const CAMrange& R3, const CAMrange& R4, const CAMrange& R5, const CAMrange& R6) const
00465 {
00466 CAMstructureBase Rstructure(Structure);
00467 Rstructure.setStructureSubset(R1,R2,R3,R4, R5, R6);
00468 CAMdoubleArray A;
00469 A.Structure.initialize(Rstructure);
00470 A.DataP = DataP;
00471 A.DataP->incrementReferenceCount();
00472 A.DataP->incrementReferenceCount();
00473 A.referenceFlag = 1;
00474 return A;
00475 };
00476 CAMdoubleArray operator() (const CAMrange& R1, const CAMrange& R2,
00477 const CAMrange& R3, const CAMrange& R4, const CAMrange& R5,
00478 const CAMrange& R6, const CAMrange& R7)
00479 {
00480 CAMstructureBase Rstructure(Structure);
00481 Rstructure.setStructureSubset(R1,R2, R3, R4, R5, R6, R7);
00482 CAMdoubleArray A;
00483 A.Structure.initialize(Rstructure);
00484 A.DataP = DataP;
00485 A.DataP->incrementReferenceCount();
00486 A.DataP->incrementReferenceCount();
00487 A.referenceFlag = 1;
00488 return A;
00489 };
00490 const CAMdoubleArray operator()(const CAMrange& R1, const CAMrange& R2,
00491 const CAMrange& R3, const CAMrange& R4, const CAMrange& R5, const CAMrange& R6,
00492 const CAMrange& R7) const
00493 {
00494 CAMstructureBase Rstructure(Structure);
00495 Rstructure.setStructureSubset(R1,R2,R3,R4, R5, R6, R7);
00496 CAMdoubleArray A;
00497 A.Structure.initialize(Rstructure);
00498 A.DataP = DataP;
00499 A.DataP->incrementReferenceCount();
00500 A.DataP->incrementReferenceCount();
00501 A.referenceFlag = 1;
00502 return A;
00503 };
00504
00505
00506
00507 double* getDataPointer() const {return (double*)DataP->getDataPointer();};
00508
00509 };
00510
00511 #endif
00512
00513
00514
00515
00516
00517
00518
00519
00520
00521
00522
00523
