3324 |
|
|
3325 |
} |
} |
3326 |
|
|
3327 |
|
{ |
3328 |
|
|
3329 |
|
cout << "\tTest slicing DataTagged with rank 3 values and one tag." << endl; |
3330 |
|
|
3331 |
|
DataArrayView::ShapeType viewShape; |
3332 |
|
viewShape.push_back(3); |
3333 |
|
viewShape.push_back(3); |
3334 |
|
viewShape.push_back(3); |
3335 |
|
|
3336 |
|
DataTagged::TagListType keys; |
3337 |
|
keys.push_back(1); |
3338 |
|
|
3339 |
|
DataTagged::ValueListType values; |
3340 |
|
|
3341 |
|
// default value |
3342 |
|
DataArrayView::ValueType viewData(27); |
3343 |
|
for (int i=0;i<viewData.size();i++) { |
3344 |
|
viewData[i]=i; |
3345 |
|
} |
3346 |
|
DataArrayView myView(viewData,viewShape); |
3347 |
|
|
3348 |
|
// value for tag "1" |
3349 |
|
DataArrayView::ValueType viewData1(27); |
3350 |
|
for (int i=0;i<viewData1.size();i++) { |
3351 |
|
viewData1[i]=i+27.0; |
3352 |
|
} |
3353 |
|
DataArrayView myView1(viewData1,viewShape); |
3354 |
|
values.push_back(myView1); |
3355 |
|
|
3356 |
|
DataTagged myData(keys,values,myView,FunctionSpace()); |
3357 |
|
|
3358 |
|
//cout << myData.toString() << endl; |
3359 |
|
|
3360 |
|
// full slice |
3361 |
|
|
3362 |
|
std::pair<int, int> region_element; |
3363 |
|
region_element.first=0; |
3364 |
|
region_element.second=3; |
3365 |
|
DataArrayView::RegionType region; |
3366 |
|
region.push_back(region_element); |
3367 |
|
region.push_back(region_element); |
3368 |
|
region.push_back(region_element); |
3369 |
|
|
3370 |
|
DataAbstract* slicedDefault = myData.getSlice(region); |
3371 |
|
|
3372 |
|
//cout << slicedDefault->toString() << endl; |
3373 |
|
|
3374 |
|
const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault); |
3375 |
|
|
3376 |
|
assert(myDataSliced->getTagLookup().size()==1); |
3377 |
|
|
3378 |
|
assert(myDataSliced->getLength()==54); |
3379 |
|
|
3380 |
|
DataArrayView myDataView = myDataSliced->getDefaultValue(); |
3381 |
|
assert(!myDataView.isEmpty()); |
3382 |
|
assert(myDataView.getOffset()==0); |
3383 |
|
assert(myDataView.getRank()==3); |
3384 |
|
assert(myDataView.noValues()==27); |
3385 |
|
assert(myDataView.getShape().size()==3); |
3386 |
|
|
3387 |
|
myDataView = myDataSliced->getDataPointByTag(1); |
3388 |
|
assert(!myDataView.isEmpty()); |
3389 |
|
assert(myDataView.getOffset()==27); |
3390 |
|
assert(myDataView.getRank()==3); |
3391 |
|
assert(myDataView.noValues()==27); |
3392 |
|
assert(myDataView.getShape().size()==3); |
3393 |
|
|
3394 |
|
// rank 1 slice |
3395 |
|
|
3396 |
|
region.clear(); |
3397 |
|
region.push_back(region_element); |
3398 |
|
region_element.second=0; |
3399 |
|
region.push_back(region_element); |
3400 |
|
region.push_back(region_element); |
3401 |
|
|
3402 |
|
slicedDefault = myData.getSlice(region); |
3403 |
|
|
3404 |
|
//cout << slicedDefault->toString() << endl; |
3405 |
|
|
3406 |
|
myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault); |
3407 |
|
|
3408 |
|
assert(myDataSliced->getTagLookup().size()==1); |
3409 |
|
|
3410 |
|
assert(myDataSliced->getLength()==6); |
3411 |
|
|
3412 |
|
myDataView = myDataSliced->getDefaultValue(); |
3413 |
|
assert(!myDataView.isEmpty()); |
3414 |
|
assert(myDataView.getOffset()==0); |
3415 |
|
assert(myDataView.getRank()==1); |
3416 |
|
assert(myDataView.noValues()==3); |
3417 |
|
assert(myDataView.getShape().size()==1); |
3418 |
|
assert(myDataView(0)==0); |
3419 |
|
assert(myDataView(1)==1); |
3420 |
|
assert(myDataView(2)==2); |
3421 |
|
|
3422 |
|
myDataView = myDataSliced->getDataPointByTag(1); |
3423 |
|
assert(!myDataView.isEmpty()); |
3424 |
|
assert(myDataView.getOffset()==3); |
3425 |
|
assert(myDataView.getRank()==1); |
3426 |
|
assert(myDataView.noValues()==3); |
3427 |
|
assert(myDataView.getShape().size()==1); |
3428 |
|
assert(myDataView(0)==27); |
3429 |
|
assert(myDataView(1)==28); |
3430 |
|
assert(myDataView(2)==29); |
3431 |
|
|
3432 |
|
// scalar slice |
3433 |
|
|
3434 |
|
region_element.first=1; |
3435 |
|
region_element.second=1; |
3436 |
|
region.clear(); |
3437 |
|
region.push_back(region_element); |
3438 |
|
region.push_back(region_element); |
3439 |
|
region.push_back(region_element); |
3440 |
|
|
3441 |
|
slicedDefault = myData.getSlice(region); |
3442 |
|
|
3443 |
|
//cout << slicedDefault->toString() << endl; |
3444 |
|
|
3445 |
|
myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault); |
3446 |
|
|
3447 |
|
assert(myDataSliced->getTagLookup().size()==1); |
3448 |
|
|
3449 |
|
assert(myDataSliced->getLength()==2); |
3450 |
|
|
3451 |
|
myDataView = myDataSliced->getDefaultValue(); |
3452 |
|
assert(!myDataView.isEmpty()); |
3453 |
|
assert(myDataView.getOffset()==0); |
3454 |
|
assert(myDataView.getRank()==0); |
3455 |
|
assert(myDataView.noValues()==1); |
3456 |
|
assert(myDataView.getShape().size()==0); |
3457 |
|
assert(myDataView()==13); |
3458 |
|
|
3459 |
|
myDataView = myDataSliced->getDataPointByTag(1); |
3460 |
|
assert(!myDataView.isEmpty()); |
3461 |
|
assert(myDataView.getOffset()==1); |
3462 |
|
assert(myDataView.getRank()==0); |
3463 |
|
assert(myDataView.noValues()==1); |
3464 |
|
assert(myDataView.getShape().size()==0); |
3465 |
|
assert(myDataView()==40); |
3466 |
|
|
3467 |
|
} |
3468 |
|
|
3469 |
|
{ |
3470 |
|
|
3471 |
|
cout << "\tTest slicing DataTagged with scalar values and three tags." << endl; |
3472 |
|
|
3473 |
|
DataTagged::TagListType keys; |
3474 |
|
keys.push_back(1); |
3475 |
|
keys.push_back(2); |
3476 |
|
keys.push_back(3); |
3477 |
|
|
3478 |
|
DataTagged::ValueListType values; |
3479 |
|
|
3480 |
|
DataArrayView::ShapeType viewShape; |
3481 |
|
|
3482 |
|
// default value |
3483 |
|
DataArrayView::ValueType viewData(1); |
3484 |
|
viewData[0]=0.0; |
3485 |
|
DataArrayView myView(viewData,viewShape); |
3486 |
|
|
3487 |
|
// value for tag "1" |
3488 |
|
DataArray eOne(myView); |
3489 |
|
eOne.getView()()=1.0; |
3490 |
|
values.push_back(eOne.getView()); |
3491 |
|
|
3492 |
|
// value for tag "2" |
3493 |
|
DataArray eTwo(myView); |
3494 |
|
eTwo.getView()()=2.0; |
3495 |
|
values.push_back(eTwo.getView()); |
3496 |
|
|
3497 |
|
// value for tag "3" |
3498 |
|
DataArray eThree(myView); |
3499 |
|
eThree.getView()()=3.0; |
3500 |
|
values.push_back(eThree.getView()); |
3501 |
|
|
3502 |
|
DataTagged myData(keys,values,myView,FunctionSpace()); |
3503 |
|
|
3504 |
|
// cout << myData.toString() << endl; |
3505 |
|
|
3506 |
|
// full slice |
3507 |
|
|
3508 |
|
DataArrayView::RegionType region; |
3509 |
|
|
3510 |
|
DataAbstract* slicedDefault = myData.getSlice(region); |
3511 |
|
|
3512 |
|
//cout << slicedDefault->toString() << endl; |
3513 |
|
|
3514 |
|
const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault); |
3515 |
|
|
3516 |
|
assert(myDataSliced->getTagLookup().size()==3); |
3517 |
|
|
3518 |
|
assert(myDataSliced->getLength()==4); |
3519 |
|
|
3520 |
|
DataArrayView myDataView = myDataSliced->getDefaultValue(); |
3521 |
|
assert(!myDataView.isEmpty()); |
3522 |
|
assert(myDataView.getOffset()==0); |
3523 |
|
assert(myDataView.getRank()==0); |
3524 |
|
assert(myDataView.noValues()==1); |
3525 |
|
assert(myDataView.getShape().size()==0); |
3526 |
|
assert(myDataView()==0); |
3527 |
|
|
3528 |
|
myDataView = myDataSliced->getDataPointByTag(1); |
3529 |
|
assert(!myDataView.isEmpty()); |
3530 |
|
assert(myDataView.getOffset()==1); |
3531 |
|
assert(myDataView.getRank()==0); |
3532 |
|
assert(myDataView.noValues()==1); |
3533 |
|
assert(myDataView.getShape().size()==0); |
3534 |
|
assert(myDataView()==1); |
3535 |
|
|
3536 |
|
myDataView = myDataSliced->getDataPointByTag(2); |
3537 |
|
assert(!myDataView.isEmpty()); |
3538 |
|
assert(myDataView.getOffset()==2); |
3539 |
|
assert(myDataView.getRank()==0); |
3540 |
|
assert(myDataView.noValues()==1); |
3541 |
|
assert(myDataView.getShape().size()==0); |
3542 |
|
assert(myDataView()==2); |
3543 |
|
|
3544 |
|
myDataView = myDataSliced->getDataPointByTag(3); |
3545 |
|
assert(!myDataView.isEmpty()); |
3546 |
|
assert(myDataView.getOffset()==3); |
3547 |
|
assert(myDataView.getRank()==0); |
3548 |
|
assert(myDataView.noValues()==1); |
3549 |
|
assert(myDataView.getShape().size()==0); |
3550 |
|
assert(myDataView()==3); |
3551 |
|
|
3552 |
|
} |
3553 |
|
|
3554 |
|
{ |
3555 |
|
|
3556 |
|
cout << "\tTest slicing DataTagged with rank 1 values and three tags." << endl; |
3557 |
|
|
3558 |
|
DataArrayView::ShapeType viewShape; |
3559 |
|
viewShape.push_back(3); |
3560 |
|
|
3561 |
|
DataTagged::TagListType keys; |
3562 |
|
keys.push_back(1); |
3563 |
|
keys.push_back(2); |
3564 |
|
keys.push_back(3); |
3565 |
|
|
3566 |
|
DataTagged::ValueListType values; |
3567 |
|
|
3568 |
|
// default value |
3569 |
|
DataArrayView::ValueType viewData(3); |
3570 |
|
for (int i=0;i<viewShape[0];i++) { |
3571 |
|
viewData[i]=i; |
3572 |
|
} |
3573 |
|
DataArrayView myView(viewData,viewShape); |
3574 |
|
|
3575 |
|
// value for tag "1" |
3576 |
|
DataArray eOne(myView); |
3577 |
|
for (int i=0;i<eOne.getView().getShape()[0];i++) { |
3578 |
|
eOne.getView()(i)=i+3.0; |
3579 |
|
} |
3580 |
|
values.push_back(eOne.getView()); |
3581 |
|
|
3582 |
|
// value for tag "2" |
3583 |
|
DataArray eTwo(myView); |
3584 |
|
for (int i=0;i<eTwo.getView().getShape()[0];i++) { |
3585 |
|
eTwo.getView()(i)=i+6.0; |
3586 |
|
} |
3587 |
|
values.push_back(eTwo.getView()); |
3588 |
|
|
3589 |
|
// value for tag "3" |
3590 |
|
DataArray eThree(myView); |
3591 |
|
for (int i=0;i<eThree.getView().getShape()[0];i++) { |
3592 |
|
eThree.getView()(i)=i+9.0; |
3593 |
|
} |
3594 |
|
values.push_back(eThree.getView()); |
3595 |
|
|
3596 |
|
DataTagged myData(keys,values,myView,FunctionSpace()); |
3597 |
|
|
3598 |
|
//cout << myData.toString() << endl; |
3599 |
|
|
3600 |
|
// full slice |
3601 |
|
|
3602 |
|
std::pair<int, int> region_element; |
3603 |
|
region_element.first=0; |
3604 |
|
region_element.second=3; |
3605 |
|
DataArrayView::RegionType region; |
3606 |
|
region.push_back(region_element); |
3607 |
|
|
3608 |
|
DataAbstract* slicedDefault = myData.getSlice(region); |
3609 |
|
|
3610 |
|
//cout << slicedDefault->toString() << endl; |
3611 |
|
|
3612 |
|
const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault); |
3613 |
|
|
3614 |
|
assert(myDataSliced->getTagLookup().size()==3); |
3615 |
|
|
3616 |
|
assert(myDataSliced->getLength()==12); |
3617 |
|
|
3618 |
|
DataArrayView myDataView = myDataSliced->getDefaultValue(); |
3619 |
|
assert(!myDataView.isEmpty()); |
3620 |
|
assert(myDataView.getOffset()==0); |
3621 |
|
assert(myDataView.getRank()==1); |
3622 |
|
assert(myDataView.noValues()==3); |
3623 |
|
assert(myDataView.getShape().size()==1); |
3624 |
|
assert(myDataView(0)==0); |
3625 |
|
assert(myDataView(1)==1); |
3626 |
|
assert(myDataView(2)==2); |
3627 |
|
|
3628 |
|
myDataView = myDataSliced->getDataPointByTag(1); |
3629 |
|
assert(!myDataView.isEmpty()); |
3630 |
|
assert(myDataView.getOffset()==3); |
3631 |
|
assert(myDataView.getRank()==1); |
3632 |
|
assert(myDataView.noValues()==3); |
3633 |
|
assert(myDataView.getShape().size()==1); |
3634 |
|
assert(myDataView(0)==3); |
3635 |
|
assert(myDataView(1)==4); |
3636 |
|
assert(myDataView(2)==5); |
3637 |
|
|
3638 |
|
myDataView = myDataSliced->getDataPointByTag(2); |
3639 |
|
assert(!myDataView.isEmpty()); |
3640 |
|
assert(myDataView.getOffset()==6); |
3641 |
|
assert(myDataView.getRank()==1); |
3642 |
|
assert(myDataView.noValues()==3); |
3643 |
|
assert(myDataView.getShape().size()==1); |
3644 |
|
assert(myDataView(0)==6); |
3645 |
|
assert(myDataView(1)==7); |
3646 |
|
assert(myDataView(2)==8); |
3647 |
|
|
3648 |
|
myDataView = myDataSliced->getDataPointByTag(3); |
3649 |
|
assert(!myDataView.isEmpty()); |
3650 |
|
assert(myDataView.getOffset()==9); |
3651 |
|
assert(myDataView.getRank()==1); |
3652 |
|
assert(myDataView.noValues()==3); |
3653 |
|
assert(myDataView.getShape().size()==1); |
3654 |
|
assert(myDataView(0)==9); |
3655 |
|
assert(myDataView(1)==10); |
3656 |
|
assert(myDataView(2)==11); |
3657 |
|
|
3658 |
|
// scalar slice |
3659 |
|
|
3660 |
|
region.clear(); |
3661 |
|
region_element.first=1; |
3662 |
|
region_element.second=1; |
3663 |
|
region.push_back(region_element); |
3664 |
|
|
3665 |
|
slicedDefault = myData.getSlice(region); |
3666 |
|
|
3667 |
|
//cout << slicedDefault->toString() << endl; |
3668 |
|
|
3669 |
|
myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault); |
3670 |
|
|
3671 |
|
assert(myDataSliced->getTagLookup().size()==3); |
3672 |
|
|
3673 |
|
assert(myDataSliced->getLength()==4); |
3674 |
|
|
3675 |
|
myDataView = myDataSliced->getDefaultValue(); |
3676 |
|
assert(!myDataView.isEmpty()); |
3677 |
|
assert(myDataView.getOffset()==0); |
3678 |
|
assert(myDataView.getRank()==0); |
3679 |
|
assert(myDataView.noValues()==1); |
3680 |
|
assert(myDataView.getShape().size()==0); |
3681 |
|
assert(myDataView()==1); |
3682 |
|
|
3683 |
|
myDataView = myDataSliced->getDataPointByTag(1); |
3684 |
|
assert(!myDataView.isEmpty()); |
3685 |
|
assert(myDataView.getOffset()==1); |
3686 |
|
assert(myDataView.getRank()==0); |
3687 |
|
assert(myDataView.noValues()==1); |
3688 |
|
assert(myDataView.getShape().size()==0); |
3689 |
|
assert(myDataView()==4); |
3690 |
|
|
3691 |
|
myDataView = myDataSliced->getDataPointByTag(2); |
3692 |
|
assert(!myDataView.isEmpty()); |
3693 |
|
assert(myDataView.getOffset()==2); |
3694 |
|
assert(myDataView.getRank()==0); |
3695 |
|
assert(myDataView.noValues()==1); |
3696 |
|
assert(myDataView.getShape().size()==0); |
3697 |
|
assert(myDataView()==7); |
3698 |
|
|
3699 |
|
myDataView = myDataSliced->getDataPointByTag(3); |
3700 |
|
assert(!myDataView.isEmpty()); |
3701 |
|
assert(myDataView.getOffset()==3); |
3702 |
|
assert(myDataView.getRank()==0); |
3703 |
|
assert(myDataView.noValues()==1); |
3704 |
|
assert(myDataView.getShape().size()==0); |
3705 |
|
assert(myDataView()==10); |
3706 |
|
|
3707 |
|
} |
3708 |
|
|
3709 |
|
{ |
3710 |
|
|
3711 |
|
cout << "\tTest slicing DataTagged with rank 3 values and three tags." << endl; |
3712 |
|
|
3713 |
|
DataArrayView::ShapeType viewShape; |
3714 |
|
viewShape.push_back(3); |
3715 |
|
viewShape.push_back(3); |
3716 |
|
viewShape.push_back(3); |
3717 |
|
|
3718 |
|
DataTagged::TagListType keys; |
3719 |
|
keys.push_back(1); |
3720 |
|
keys.push_back(2); |
3721 |
|
keys.push_back(3); |
3722 |
|
|
3723 |
|
DataTagged::ValueListType values; |
3724 |
|
|
3725 |
|
// default value |
3726 |
|
DataArrayView::ValueType viewData(27); |
3727 |
|
for (int i=0;i<viewData.size();i++) { |
3728 |
|
viewData[i]=i; |
3729 |
|
} |
3730 |
|
DataArrayView myView(viewData,viewShape); |
3731 |
|
|
3732 |
|
// value for tag "1" |
3733 |
|
DataArrayView::ValueType viewData1(27); |
3734 |
|
for (int i=0;i<viewData1.size();i++) { |
3735 |
|
viewData1[i]=i+27.0; |
3736 |
|
} |
3737 |
|
DataArrayView myView1(viewData1,viewShape); |
3738 |
|
values.push_back(myView1); |
3739 |
|
|
3740 |
|
// value for tag "2" |
3741 |
|
DataArrayView::ValueType viewData2(27); |
3742 |
|
for (int i=0;i<viewData2.size();i++) { |
3743 |
|
viewData2[i]=i+54.0; |
3744 |
|
} |
3745 |
|
DataArrayView myView2(viewData2,viewShape); |
3746 |
|
values.push_back(myView2); |
3747 |
|
|
3748 |
|
// value for tag "3" |
3749 |
|
DataArrayView::ValueType viewData3(27); |
3750 |
|
for (int i=0;i<viewData3.size();i++) { |
3751 |
|
viewData3[i]=i+81.0; |
3752 |
|
} |
3753 |
|
DataArrayView myView3(viewData3,viewShape); |
3754 |
|
values.push_back(myView3); |
3755 |
|
|
3756 |
|
DataTagged myData(keys,values,myView,FunctionSpace()); |
3757 |
|
|
3758 |
|
//cout << myData.toString() << endl; |
3759 |
|
|
3760 |
|
// full slice |
3761 |
|
|
3762 |
|
std::pair<int, int> region_element; |
3763 |
|
region_element.first=0; |
3764 |
|
region_element.second=3; |
3765 |
|
DataArrayView::RegionType region; |
3766 |
|
region.push_back(region_element); |
3767 |
|
region.push_back(region_element); |
3768 |
|
region.push_back(region_element); |
3769 |
|
|
3770 |
|
DataAbstract* slicedDefault = myData.getSlice(region); |
3771 |
|
|
3772 |
|
//cout << slicedDefault->toString() << endl; |
3773 |
|
|
3774 |
|
const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault); |
3775 |
|
|
3776 |
|
assert(myDataSliced->getTagLookup().size()==3); |
3777 |
|
|
3778 |
|
assert(myDataSliced->getLength()==108); |
3779 |
|
|
3780 |
|
DataArrayView myDataView = myDataSliced->getDefaultValue(); |
3781 |
|
assert(!myDataView.isEmpty()); |
3782 |
|
assert(myDataView.getOffset()==0); |
3783 |
|
assert(myDataView.getRank()==3); |
3784 |
|
assert(myDataView.noValues()==27); |
3785 |
|
assert(myDataView.getShape().size()==3); |
3786 |
|
|
3787 |
|
myDataView = myDataSliced->getDataPointByTag(1); |
3788 |
|
assert(!myDataView.isEmpty()); |
3789 |
|
assert(myDataView.getOffset()==27); |
3790 |
|
assert(myDataView.getRank()==3); |
3791 |
|
assert(myDataView.noValues()==27); |
3792 |
|
assert(myDataView.getShape().size()==3); |
3793 |
|
|
3794 |
|
myDataView = myDataSliced->getDataPointByTag(2); |
3795 |
|
assert(!myDataView.isEmpty()); |
3796 |
|
assert(myDataView.getOffset()==54); |
3797 |
|
assert(myDataView.getRank()==3); |
3798 |
|
assert(myDataView.noValues()==27); |
3799 |
|
assert(myDataView.getShape().size()==3); |
3800 |
|
|
3801 |
|
myDataView = myDataSliced->getDataPointByTag(3); |
3802 |
|
assert(!myDataView.isEmpty()); |
3803 |
|
assert(myDataView.getOffset()==81); |
3804 |
|
assert(myDataView.getRank()==3); |
3805 |
|
assert(myDataView.noValues()==27); |
3806 |
|
assert(myDataView.getShape().size()==3); |
3807 |
|
|
3808 |
|
// rank 1 slice |
3809 |
|
|
3810 |
|
region.clear(); |
3811 |
|
region.push_back(region_element); |
3812 |
|
region_element.second=0; |
3813 |
|
region.push_back(region_element); |
3814 |
|
region.push_back(region_element); |
3815 |
|
|
3816 |
|
slicedDefault = myData.getSlice(region); |
3817 |
|
|
3818 |
|
// cout << slicedDefault->toString() << endl; |
3819 |
|
|
3820 |
|
myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault); |
3821 |
|
|
3822 |
|
assert(myDataSliced->getTagLookup().size()==3); |
3823 |
|
|
3824 |
|
assert(myDataSliced->getLength()==12); |
3825 |
|
|
3826 |
|
myDataView = myDataSliced->getDefaultValue(); |
3827 |
|
assert(!myDataView.isEmpty()); |
3828 |
|
assert(myDataView.getOffset()==0); |
3829 |
|
assert(myDataView.getRank()==1); |
3830 |
|
assert(myDataView.noValues()==3); |
3831 |
|
assert(myDataView.getShape().size()==1); |
3832 |
|
assert(myDataView(0)==0); |
3833 |
|
assert(myDataView(1)==1); |
3834 |
|
assert(myDataView(2)==2); |
3835 |
|
|
3836 |
|
myDataView = myDataSliced->getDataPointByTag(1); |
3837 |
|
assert(!myDataView.isEmpty()); |
3838 |
|
assert(myDataView.getOffset()==3); |
3839 |
|
assert(myDataView.getRank()==1); |
3840 |
|
assert(myDataView.noValues()==3); |
3841 |
|
assert(myDataView.getShape().size()==1); |
3842 |
|
assert(myDataView(0)==27); |
3843 |
|
assert(myDataView(1)==28); |
3844 |
|
assert(myDataView(2)==29); |
3845 |
|
|
3846 |
|
myDataView = myDataSliced->getDataPointByTag(2); |
3847 |
|
assert(!myDataView.isEmpty()); |
3848 |
|
assert(myDataView.getOffset()==6); |
3849 |
|
assert(myDataView.getRank()==1); |
3850 |
|
assert(myDataView.noValues()==3); |
3851 |
|
assert(myDataView.getShape().size()==1); |
3852 |
|
assert(myDataView(0)==54); |
3853 |
|
assert(myDataView(1)==55); |
3854 |
|
assert(myDataView(2)==56); |
3855 |
|
|
3856 |
|
myDataView = myDataSliced->getDataPointByTag(3); |
3857 |
|
assert(!myDataView.isEmpty()); |
3858 |
|
assert(myDataView.getOffset()==9); |
3859 |
|
assert(myDataView.getRank()==1); |
3860 |
|
assert(myDataView.noValues()==3); |
3861 |
|
assert(myDataView.getShape().size()==1); |
3862 |
|
assert(myDataView(0)==81); |
3863 |
|
assert(myDataView(1)==82); |
3864 |
|
assert(myDataView(2)==83); |
3865 |
|
|
3866 |
|
// scalar slice |
3867 |
|
|
3868 |
|
region_element.first=1; |
3869 |
|
region_element.second=1; |
3870 |
|
region.clear(); |
3871 |
|
region.push_back(region_element); |
3872 |
|
region.push_back(region_element); |
3873 |
|
region.push_back(region_element); |
3874 |
|
|
3875 |
|
slicedDefault = myData.getSlice(region); |
3876 |
|
|
3877 |
|
//cout << slicedDefault->toString() << endl; |
3878 |
|
|
3879 |
|
myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault); |
3880 |
|
|
3881 |
|
assert(myDataSliced->getTagLookup().size()==3); |
3882 |
|
|
3883 |
|
assert(myDataSliced->getLength()==4); |
3884 |
|
|
3885 |
|
myDataView = myDataSliced->getDefaultValue(); |
3886 |
|
assert(!myDataView.isEmpty()); |
3887 |
|
assert(myDataView.getOffset()==0); |
3888 |
|
assert(myDataView.getRank()==0); |
3889 |
|
assert(myDataView.noValues()==1); |
3890 |
|
assert(myDataView.getShape().size()==0); |
3891 |
|
assert(myDataView()==13); |
3892 |
|
|
3893 |
|
myDataView = myDataSliced->getDataPointByTag(1); |
3894 |
|
assert(!myDataView.isEmpty()); |
3895 |
|
assert(myDataView.getOffset()==1); |
3896 |
|
assert(myDataView.getRank()==0); |
3897 |
|
assert(myDataView.noValues()==1); |
3898 |
|
assert(myDataView.getShape().size()==0); |
3899 |
|
assert(myDataView()==40); |
3900 |
|
|
3901 |
|
myDataView = myDataSliced->getDataPointByTag(2); |
3902 |
|
assert(!myDataView.isEmpty()); |
3903 |
|
assert(myDataView.getOffset()==2); |
3904 |
|
assert(myDataView.getRank()==0); |
3905 |
|
assert(myDataView.noValues()==1); |
3906 |
|
assert(myDataView.getShape().size()==0); |
3907 |
|
assert(myDataView()==67); |
3908 |
|
|
3909 |
|
myDataView = myDataSliced->getDataPointByTag(3); |
3910 |
|
assert(!myDataView.isEmpty()); |
3911 |
|
assert(myDataView.getOffset()==3); |
3912 |
|
assert(myDataView.getRank()==0); |
3913 |
|
assert(myDataView.noValues()==1); |
3914 |
|
assert(myDataView.getShape().size()==0); |
3915 |
|
assert(myDataView()==94); |
3916 |
|
|
3917 |
|
} |
3918 |
|
|
3919 |
} |
} |
3920 |
|
|
3921 |
void DataTaggedTestCase::testSetSlice() { |
void DataTaggedTestCase::testSetSlice() { |