void GoalDetector::execute()
{
getGoalPercept().reset();
//if there is no field percept, then, there is also no goal ?!
/*
if(!theFieldPercept.isValid())
{
return;
}
*/
// estimate the horizon
Vector2<double> p1(getArtificialHorizon().begin());
Vector2<double> p2(getArtificialHorizon().end());
int heightOfHorizon = (int)((p1.y + p2.y) * 0.5 + 0.5);
// image over the horizon
if(heightOfHorizon > (int)getImage().cameraInfo.resolutionHeight-10) return;
// clamp the scanline
p1.y = Math::clamp((int)p1.y, 10, (int)getImage().cameraInfo.resolutionHeight-10);
p2.y = Math::clamp((int)p2.y, 10, (int)getImage().cameraInfo.resolutionHeight-10);
// calculate the post candidates along of the horizon
Candidate candidates[maxNumberOfCandidates];
int numberOfCandidates = scanForCandidates(p1, p2, candidates);
// fallback: try to scan along the center of the image
if(numberOfCandidates == 0)
{
Vector2<double> c1(0,getImage().cameraInfo.getOpticalCenterY());
Vector2<double> c2(getImage().cameraInfo.resolutionWidth-1,getImage().cameraInfo.getOpticalCenterY());
numberOfCandidates = scanForCandidates(c1, c2, candidates);
}//end if
// try once again...
if(numberOfCandidates == 0)
{
Vector2<double> c1(0,getImage().cameraInfo.resolutionHeight/3);
Vector2<double> c2(getImage().cameraInfo.resolutionWidth-1,getImage().cameraInfo.resolutionHeight/3);
numberOfCandidates = scanForCandidates(c1, c2, candidates);
}//end if
// estimate the post base points
vector<GoalPercept::GoalPost> postvector;
estimatePostsByScanlines(candidates, numberOfCandidates, postvector);
//estimatePostsByBlobs(candidates, numberOfCandidates, postvector);
if(postvector.empty()) return;
// sort the posts by height in the image
// the first is the biggest
GoalPercept::GoalPost post; // only for comparison
sort(postvector.begin(), postvector.end(), post);
// minimal height (in px) of an accepted goal post
int minimalHeightOfAGoalPost = 20;
int numberOfPostsFound = 0;
// we are searching for two goal posts
GoalPercept::GoalPost postOne;
GoalPercept::GoalPost postTwo;
int distToBottomImage = getImage().cameraInfo.resolutionHeight - max(postOne.basePoint.y, postTwo.basePoint.y) - 1;
// look max 5 pixel down
Vector2<int> extraBase(0, min(distToBottomImage,5));
// if the longest post is to short
if(postvector.begin()->seenHeight < minimalHeightOfAGoalPost)
{
return;
}
// index of the first found post
unsigned int idxFirst = 0;
// search for the first goal post candidate
for(idxFirst = 0; idxFirst < postvector.size(); idxFirst++)
{
if(postvector[idxFirst].seenHeight >= minimalHeightOfAGoalPost)
// consider the field percept ONLY if it is valid
//&& theFieldPercept.getLargestValidPoly(getCameraMatrix().horizon).isInside(postvector[idxFirst].basePoint + extraBase))
{
numberOfPostsFound = 1;
break;
}
}//end for
// if a post were found search for the second one
if(numberOfPostsFound > 0)
{
// at least one post was seen
postOne = postvector[idxFirst];
idxFirst++;
for(unsigned int i = idxFirst; i < postvector.size(); i++)
{
postTwo = postvector[i];
if( abs(postTwo.basePoint.x - postOne.basePoint.x) > 50 &&
postTwo.seenHeight > minimalHeightOfAGoalPost &&
postOne.color == postTwo.color) //&& // posts have the same color
// consider the field percept ONLY if it is valid
//theFieldPercept.getLargestValidPoly(getCameraMatrix().horizon).isInside(postvector[i].basePoint + extraBase))
{
numberOfPostsFound = 2;
break;
}//end if
}//end for
}//end if first found
if(numberOfPostsFound > 1)
{
// sort: which one is left or right
if(postOne.basePoint.x > postTwo.basePoint.x)
{
postOne.type = GoalPercept::GoalPost::rightPost;
postTwo.type = GoalPercept::GoalPost::leftPost;
}else
{
postOne.type = GoalPercept::GoalPost::leftPost;
postTwo.type = GoalPercept::GoalPost::rightPost;
}
//TODO: handle the case if the projection is not possible
// position on the ground is not reliable if the post cannot be projected
postOne.positionReliable =
CameraGeometry::imagePixelToFieldCoord(
getCameraMatrix(),
getImage().cameraInfo,
postOne.basePoint.x, postOne.basePoint.y, 0.0,
postOne.position);
//TODO: handle the case if the projection is not possible
// position on the ground is not reliable if the post cannot be projected
postTwo.positionReliable =
CameraGeometry::imagePixelToFieldCoord(
getCameraMatrix(),
getImage().cameraInfo,
postTwo.basePoint.x, postTwo.basePoint.y, 0.0,
postTwo.position);
//TODO: try to calculate the position by the top of the post
// translate by the post radius
postOne.position.normalize(postOne.position.abs() + getFieldInfo().goalpostRadius);
postTwo.position.normalize(postTwo.position.abs() + getFieldInfo().goalpostRadius);
postOne.positionReliable = postOne.positionReliable && checkIfPostReliable(postOne.basePoint);
postTwo.positionReliable = postTwo.positionReliable && checkIfPostReliable(postTwo.basePoint);
getGoalPercept().add(postOne);
getGoalPercept().add(postTwo);
}
else if(numberOfPostsFound > 0) // only one post found
{
//TODO: handle the case if the projection is not possible
postOne.positionReliable =
CameraGeometry::imagePixelToFieldCoord(
getCameraMatrix(),
getImage().cameraInfo,
postOne.basePoint.x, postOne.basePoint.y, 0.0,
postOne.position);
postOne.positionReliable = postOne.positionReliable && checkIfPostReliable(postOne.basePoint);
postOne.type = GoalPercept::GoalPost::unknownPost;
getGoalPercept().add(postOne);
}//end else
/*************************************************/
// calculate the centroid
// at least one post was seen
// TODO: clean it up (calculation of the centroid)
if(getGoalPercept().getNumberOfSeenPosts() > 0)
{
//Vector2<double> centroid;
//double mainAxisAngle = -getMajorAxis( goalColor, centroid);
Vector2<double> centroid = getGoalPercept().getPost(0).basePoint -
Vector2<double>(0.0, getGoalPercept().getPost(0).seenHeight*0.5);
if(getGoalPercept().getNumberOfSeenPosts() > 1)
{
centroid += getGoalPercept().getPost(1).basePoint -
Vector2<double>(0.0, getGoalPercept().getPost(1).seenHeight*0.5);
centroid /= 2.0;
}//end if
Vector2<double> angles = CameraGeometry::angleToPointInImage(
getCameraMatrix(),
getImage().cameraInfo,
(int)centroid.x,
(int)centroid.y);
getGoalPercept().angleToSeenGoal = angles.x;
getGoalPercept().goalCentroid = CameraGeometry::imagePixelToWorld(
getCameraMatrix(),
getImage().cameraInfo,
centroid.x,
centroid.y,
3000.0);
DEBUG_REQUEST("ImageProcessor:GoalDetector:mark_goal",
CIRCLE_PX(ColorClasses::red, (int)centroid.x, (int)centroid.y, 5);
);
int tc_libcxx_containers_unord_map_swap_member(void)
{
{
typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare;
typedef test_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
C c1(0, Hash(1), Compare(1), Alloc(1, 1));
C c2(0, Hash(2), Compare(2), Alloc(1, 2));
c2.max_load_factor(2);
c1.swap(c2);
LIBCPP_ASSERT(c1.bucket_count() == 0);
TC_ASSERT_EXPR(c1.size() == 0);
TC_ASSERT_EXPR(c1.hash_function() == Hash(2));
TC_ASSERT_EXPR(c1.key_eq() == Compare(2));
TC_ASSERT_EXPR(c1.get_allocator().get_id() == 1);
TC_ASSERT_EXPR(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
TC_ASSERT_EXPR(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
TC_ASSERT_EXPR(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
TC_ASSERT_EXPR(c2.size() == 0);
TC_ASSERT_EXPR(c2.hash_function() == Hash(1));
TC_ASSERT_EXPR(c2.key_eq() == Compare(1));
TC_ASSERT_EXPR(c2.get_allocator().get_id() == 2);
TC_ASSERT_EXPR(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
TC_ASSERT_EXPR(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
TC_ASSERT_EXPR(c2.max_load_factor() == 1);
}
{
typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare;
typedef test_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P;
P a2[] =
{
P(10, "ten"),
P(20, "twenty"),
P(30, "thirty"),
P(40, "forty"),
P(50, "fifty"),
P(60, "sixty"),
P(70, "seventy"),
P(80, "eighty"),
};
C c1(0, Hash(1), Compare(1), Alloc(1, 1));
C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(1, 2));
c2.max_load_factor(2);
c1.swap(c2);
TC_ASSERT_EXPR(c1.bucket_count() >= 8);
TC_ASSERT_EXPR(c1.size() == 8);
TC_ASSERT_EXPR(c1.at(10) == "ten");
TC_ASSERT_EXPR(c1.at(20) == "twenty");
TC_ASSERT_EXPR(c1.at(30) == "thirty");
TC_ASSERT_EXPR(c1.at(40) == "forty");
TC_ASSERT_EXPR(c1.at(50) == "fifty");
TC_ASSERT_EXPR(c1.at(60) == "sixty");
TC_ASSERT_EXPR(c1.at(70) == "seventy");
TC_ASSERT_EXPR(c1.at(80) == "eighty");
TC_ASSERT_EXPR(c1.hash_function() == Hash(2));
TC_ASSERT_EXPR(c1.key_eq() == Compare(2));
TC_ASSERT_EXPR(c1.get_allocator().get_id() == 1);
TC_ASSERT_EXPR(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
TC_ASSERT_EXPR(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
TC_ASSERT_EXPR(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
TC_ASSERT_EXPR(c2.size() == 0);
TC_ASSERT_EXPR(c2.hash_function() == Hash(1));
TC_ASSERT_EXPR(c2.key_eq() == Compare(1));
TC_ASSERT_EXPR(c2.get_allocator().get_id() == 2);
TC_ASSERT_EXPR(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
TC_ASSERT_EXPR(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
TC_ASSERT_EXPR(c2.max_load_factor() == 1);
}
{
typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare;
typedef test_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P;
P a1[] =
{
P(1, "one"),
P(2, "two"),
P(3, "three"),
P(4, "four"),
P(1, "four"),
P(2, "four"),
};
C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1, 1));
C c2(0, Hash(2), Compare(2), Alloc(1, 2));
c2.max_load_factor(2);
c1.swap(c2);
LIBCPP_ASSERT(c1.bucket_count() == 0);
TC_ASSERT_EXPR(c1.size() == 0);
TC_ASSERT_EXPR(c1.hash_function() == Hash(2));
TC_ASSERT_EXPR(c1.key_eq() == Compare(2));
TC_ASSERT_EXPR(c1.get_allocator().get_id() == 1);
TC_ASSERT_EXPR(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
TC_ASSERT_EXPR(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
TC_ASSERT_EXPR(c1.max_load_factor() == 2);
TC_ASSERT_EXPR(c2.bucket_count() >= 4);
TC_ASSERT_EXPR(c2.size() == 4);
TC_ASSERT_EXPR(c2.at(1) == "one");
TC_ASSERT_EXPR(c2.at(2) == "two");
TC_ASSERT_EXPR(c2.at(3) == "three");
TC_ASSERT_EXPR(c2.at(4) == "four");
TC_ASSERT_EXPR(c2.hash_function() == Hash(1));
TC_ASSERT_EXPR(c2.key_eq() == Compare(1));
TC_ASSERT_EXPR(c2.get_allocator().get_id() == 2);
TC_ASSERT_EXPR(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
TC_ASSERT_EXPR(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
TC_ASSERT_EXPR(c2.max_load_factor() == 1);
}
{
typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare;
typedef test_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P;
P a1[] =
{
P(1, "one"),
P(2, "two"),
P(3, "three"),
P(4, "four"),
P(1, "four"),
P(2, "four"),
};
P a2[] =
{
P(10, "ten"),
P(20, "twenty"),
P(30, "thirty"),
P(40, "forty"),
P(50, "fifty"),
P(60, "sixty"),
P(70, "seventy"),
P(80, "eighty"),
};
C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1, 1));
C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(1, 2));
c2.max_load_factor(2);
c1.swap(c2);
TC_ASSERT_EXPR(c1.bucket_count() >= 8);
TC_ASSERT_EXPR(c1.size() == 8);
TC_ASSERT_EXPR(c1.at(10) == "ten");
TC_ASSERT_EXPR(c1.at(20) == "twenty");
TC_ASSERT_EXPR(c1.at(30) == "thirty");
TC_ASSERT_EXPR(c1.at(40) == "forty");
TC_ASSERT_EXPR(c1.at(50) == "fifty");
TC_ASSERT_EXPR(c1.at(60) == "sixty");
TC_ASSERT_EXPR(c1.at(70) == "seventy");
TC_ASSERT_EXPR(c1.at(80) == "eighty");
TC_ASSERT_EXPR(c1.hash_function() == Hash(2));
TC_ASSERT_EXPR(c1.key_eq() == Compare(2));
TC_ASSERT_EXPR(c1.get_allocator().get_id() == 1);
TC_ASSERT_EXPR(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
TC_ASSERT_EXPR(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
TC_ASSERT_EXPR(c1.max_load_factor() == 2);
TC_ASSERT_EXPR(c2.bucket_count() >= 4);
TC_ASSERT_EXPR(c2.size() == 4);
TC_ASSERT_EXPR(c2.at(1) == "one");
TC_ASSERT_EXPR(c2.at(2) == "two");
TC_ASSERT_EXPR(c2.at(3) == "three");
TC_ASSERT_EXPR(c2.at(4) == "four");
TC_ASSERT_EXPR(c2.hash_function() == Hash(1));
TC_ASSERT_EXPR(c2.key_eq() == Compare(1));
TC_ASSERT_EXPR(c2.get_allocator().get_id() == 2);
TC_ASSERT_EXPR(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
TC_ASSERT_EXPR(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
TC_ASSERT_EXPR(c2.max_load_factor() == 1);
}
{
typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare;
typedef other_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
C c1(0, Hash(1), Compare(1), Alloc(1));
C c2(0, Hash(2), Compare(2), Alloc(2));
c2.max_load_factor(2);
c1.swap(c2);
LIBCPP_ASSERT(c1.bucket_count() == 0);
TC_ASSERT_EXPR(c1.size() == 0);
TC_ASSERT_EXPR(c1.hash_function() == Hash(2));
TC_ASSERT_EXPR(c1.key_eq() == Compare(2));
TC_ASSERT_EXPR(c1.get_allocator() == Alloc(2));
TC_ASSERT_EXPR(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
TC_ASSERT_EXPR(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
TC_ASSERT_EXPR(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
TC_ASSERT_EXPR(c2.size() == 0);
TC_ASSERT_EXPR(c2.hash_function() == Hash(1));
TC_ASSERT_EXPR(c2.key_eq() == Compare(1));
TC_ASSERT_EXPR(c2.get_allocator() == Alloc(1));
TC_ASSERT_EXPR(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
TC_ASSERT_EXPR(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
TC_ASSERT_EXPR(c2.max_load_factor() == 1);
}
{
typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare;
typedef other_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P;
P a2[] =
{
P(10, "ten"),
P(20, "twenty"),
P(30, "thirty"),
P(40, "forty"),
P(50, "fifty"),
P(60, "sixty"),
P(70, "seventy"),
P(80, "eighty"),
};
C c1(0, Hash(1), Compare(1), Alloc(1));
C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2));
c2.max_load_factor(2);
c1.swap(c2);
TC_ASSERT_EXPR(c1.bucket_count() >= 8);
TC_ASSERT_EXPR(c1.size() == 8);
TC_ASSERT_EXPR(c1.at(10) == "ten");
TC_ASSERT_EXPR(c1.at(20) == "twenty");
TC_ASSERT_EXPR(c1.at(30) == "thirty");
TC_ASSERT_EXPR(c1.at(40) == "forty");
TC_ASSERT_EXPR(c1.at(50) == "fifty");
TC_ASSERT_EXPR(c1.at(60) == "sixty");
TC_ASSERT_EXPR(c1.at(70) == "seventy");
TC_ASSERT_EXPR(c1.at(80) == "eighty");
TC_ASSERT_EXPR(c1.hash_function() == Hash(2));
TC_ASSERT_EXPR(c1.key_eq() == Compare(2));
TC_ASSERT_EXPR(c1.get_allocator() == Alloc(2));
TC_ASSERT_EXPR(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
TC_ASSERT_EXPR(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
TC_ASSERT_EXPR(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
TC_ASSERT_EXPR(c2.size() == 0);
TC_ASSERT_EXPR(c2.hash_function() == Hash(1));
TC_ASSERT_EXPR(c2.key_eq() == Compare(1));
TC_ASSERT_EXPR(c2.get_allocator() == Alloc(1));
TC_ASSERT_EXPR(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
TC_ASSERT_EXPR(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
TC_ASSERT_EXPR(c2.max_load_factor() == 1);
}
{
typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare;
typedef other_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P;
P a1[] =
{
P(1, "one"),
P(2, "two"),
P(3, "three"),
P(4, "four"),
P(1, "four"),
P(2, "four"),
};
C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1));
C c2(0, Hash(2), Compare(2), Alloc(2));
c2.max_load_factor(2);
c1.swap(c2);
LIBCPP_ASSERT(c1.bucket_count() == 0);
TC_ASSERT_EXPR(c1.size() == 0);
TC_ASSERT_EXPR(c1.hash_function() == Hash(2));
TC_ASSERT_EXPR(c1.key_eq() == Compare(2));
TC_ASSERT_EXPR(c1.get_allocator() == Alloc(2));
TC_ASSERT_EXPR(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
TC_ASSERT_EXPR(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
TC_ASSERT_EXPR(c1.max_load_factor() == 2);
TC_ASSERT_EXPR(c2.bucket_count() >= 4);
TC_ASSERT_EXPR(c2.size() == 4);
TC_ASSERT_EXPR(c2.at(1) == "one");
TC_ASSERT_EXPR(c2.at(2) == "two");
TC_ASSERT_EXPR(c2.at(3) == "three");
TC_ASSERT_EXPR(c2.at(4) == "four");
TC_ASSERT_EXPR(c2.hash_function() == Hash(1));
TC_ASSERT_EXPR(c2.key_eq() == Compare(1));
TC_ASSERT_EXPR(c2.get_allocator() == Alloc(1));
TC_ASSERT_EXPR(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
TC_ASSERT_EXPR(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
TC_ASSERT_EXPR(c2.max_load_factor() == 1);
}
{
typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare;
typedef other_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P;
P a1[] =
{
P(1, "one"),
P(2, "two"),
P(3, "three"),
P(4, "four"),
P(1, "four"),
P(2, "four"),
};
P a2[] =
{
P(10, "ten"),
P(20, "twenty"),
P(30, "thirty"),
P(40, "forty"),
P(50, "fifty"),
P(60, "sixty"),
P(70, "seventy"),
P(80, "eighty"),
};
C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1));
C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2));
c2.max_load_factor(2);
c1.swap(c2);
TC_ASSERT_EXPR(c1.bucket_count() >= 8);
TC_ASSERT_EXPR(c1.size() == 8);
TC_ASSERT_EXPR(c1.at(10) == "ten");
TC_ASSERT_EXPR(c1.at(20) == "twenty");
TC_ASSERT_EXPR(c1.at(30) == "thirty");
TC_ASSERT_EXPR(c1.at(40) == "forty");
TC_ASSERT_EXPR(c1.at(50) == "fifty");
TC_ASSERT_EXPR(c1.at(60) == "sixty");
TC_ASSERT_EXPR(c1.at(70) == "seventy");
TC_ASSERT_EXPR(c1.at(80) == "eighty");
TC_ASSERT_EXPR(c1.hash_function() == Hash(2));
TC_ASSERT_EXPR(c1.key_eq() == Compare(2));
TC_ASSERT_EXPR(c1.get_allocator() == Alloc(2));
TC_ASSERT_EXPR(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
TC_ASSERT_EXPR(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
TC_ASSERT_EXPR(c1.max_load_factor() == 2);
TC_ASSERT_EXPR(c2.bucket_count() >= 4);
TC_ASSERT_EXPR(c2.size() == 4);
TC_ASSERT_EXPR(c2.at(1) == "one");
TC_ASSERT_EXPR(c2.at(2) == "two");
TC_ASSERT_EXPR(c2.at(3) == "three");
TC_ASSERT_EXPR(c2.at(4) == "four");
TC_ASSERT_EXPR(c2.hash_function() == Hash(1));
TC_ASSERT_EXPR(c2.key_eq() == Compare(1));
TC_ASSERT_EXPR(c2.get_allocator() == Alloc(1));
TC_ASSERT_EXPR(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
TC_ASSERT_EXPR(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
TC_ASSERT_EXPR(c2.max_load_factor() == 1);
}
TC_SUCCESS_RESULT();
return 0;
}
int main(int argc, char *argv[])
{
Pooma::initialize(argc, argv);
Pooma::Tester tester(argc, argv);
Interval<1> n1(1,5);
Interval<1> n2(4,8);
Interval<1> n3(10,20);
Interval<2> a(n1,n2);
Interval<3> b(n1,n2,n3);
Range<1> r1(1,5);
Range<1> r2(4,8,2);
Range<1> r3(5,9,2);
Range<1> r4(10,20,5);
Range<2> ra(r1,r2);
Range<2> rb(r1,r3);
Range<3> rc(r1,r2,r3);
tester.out() << "1: touches(" << a[0] << "," << a[1] << ") ? ";
tester.out() << touches(a[0], a[1]) << std::endl;
tester.check( touches(a[0], a[1]) );
tester.out() << "0: touches(" << a[0] << "," << b[2] << ") ? ";
tester.out() << touches(a[0], b[2]) << std::endl;
tester.check( touches(a[0], b[2])==0);
tester.out() << "1: touches(" << a[0] << "," << ra[0] << ") ? ";
tester.out() << touches(a[0], ra[0]) << std::endl;
tester.check(touches(a[0], ra[0]));
tester.out() << "1: touches(" << ra[0] << "," << ra[1] << ") ? ";
tester.out() << touches(ra[0], ra[1]) << std::endl;
tester.check( touches(ra[0], ra[1]));
tester.out() << "0: touches(" << r2 << "," << r3 << ") ? ";
tester.out() << touches(r2, r3) << std::endl;
tester.check( touches(r2, r3)==0);
tester.out() << "0: touches(" << ra << "," << rb << ") ? ";
tester.out() << touches(ra, rb) << std::endl;
tester.check( touches(ra, rb) ==0);
tester.out() << "1: touches(" << rc << "," << rc << ") ? ";
tester.out() << touches(rc, rc) << std::endl;
tester.check( touches(rc, rc) );
tester.out() << "------------------------------------" << std::endl;
tester.check(" touches ", true);
Interval<1> c1(1,10);
Interval<1> c2(3,8);
Interval<1> c3(5,15);
Interval<2> ca(c1, c1);
Interval<2> cb(c1, c2);
Range<1> cr1(2,20,2);
Range<1> cr2(4,16,4);
Range<1> cr3(3,15,2);
Range<1> cr4(5,15,5);
tester.out() << "1: contains(" << c1 << "," << c2 << ") ? ";
tester.out() << contains(c1,c2) << std::endl;
tester.check(contains(c1,c2));
tester.out() << "0: contains(" << c2 << "," << c1 << ") ? ";
tester.out() << contains(c2,c1) << std::endl;
tester.check(contains(c2,c1)==0);
tester.out() << "0: contains(" << c1 << "," << c3 << ") ? ";
tester.out() << contains(c1,c3) << std::endl;
tester.check(contains(c1,c3)==0);
tester.out() << "1: contains(" << ca << "," << cb << ") ? ";
tester.out() << contains(ca,cb) << std::endl;
tester.check(contains(ca,cb));
tester.out() << "0: contains(" << cb << "," << ca << ") ? ";
tester.out() << contains(cb,ca) << std::endl;
tester.check(contains(cb,ca)==0);
tester.out() << "1: contains(" << cr1 << "," << cr2 << ") ? ";
tester.out() << contains(cr1,cr2) << std::endl;
tester.check( contains(cr1,cr2));
tester.out() << "0: contains(" << cr1 << "," << cr3 << ") ? ";
tester.out() << contains(cr1,cr3) << std::endl;
tester.check(contains(cr1,cr3)==0);
tester.out() << "1: contains(" << c3 << "," << cr4 << ") ? ";
tester.out() << contains(c3,cr4) << std::endl;
tester.check(contains(c3,cr4));
tester.out() << "0: contains(" << cr4 << "," << c3 << ") ? ";
tester.out() << contains(cr4,c3) << std::endl;
tester.check(contains(cr4,c3)==0);
tester.out() << "------------------------------------" << std::endl;
Interval<2> s1, s2;
Range<2> sr1, sr2;
split(cb, s1, s2);
tester.out() << "split(" << cb << ") = " << s1 << " and " << s2 << std::endl;
tester.check(s1==Interval<2>(Interval<1>(1,5),Interval<1>(3,5)));
tester.check(s2==Interval<2>(Interval<1>(6,10),Interval<1>(6,8)));
split(rb, sr1, sr2);
tester.out() << "split(" << rb << ") = " << sr1 << " and " << sr2 << std::endl;
tester.check(sr1==Range<2>(Range<1>(1,2),Range<1>(5,5,2)));
tester.check(sr2==Range<2>(Range<1>(3,5),Range<1>(7,9,2)));
tester.out() << "------------------------------------" << std::endl;
tester.out() << "intersect(" << cb << "," << ca << ") = ";
tester.out() << intersect(cb,ca) << std::endl;
tester.check(intersect(cb,ca)==Interval<2>(Interval<1>(1,10),
Interval<1>(3,8)));
tester.out() << "intersect(" << rb << "," << ra << ") = ";
tester.out() << intersect(rb,ra) << std::endl;
Range<1> i1(1,16,3);
Range<1> i2(17,3,-2);
tester.out() << "intersect(" << i1 << "," << i2 << ") = ";
tester.out() << intersect(i1,i2) << std::endl;
tester.check( intersect(i1,i2) == Range<1>(7,14,6));
tester.out() << "intersect(" << i2 << "," << i1 << ") = ";
tester.out() << intersect(i2,i1) << std::endl;
tester.check( intersect(i2,i1) == Range<1>(13,7,-6));
tester.out() << "------------------------------------" << std::endl;
Interval<1> eq1(1,5);
Range<1> eq2 = -2 * eq1 + 3;
Range<1> eq3(-8,8,4);
Range<1> eq4 = 3 * eq1;
Range<1> eq5 = 2 * eq1;
Range<1> eq6 = 6 * eq1 + 1;
tester.out() << "For " << eq1 << " --> " << eq4 << ", then " << eq3 << " --> ";
tester.out() << equivSubset(eq1,eq4,eq3) << std::endl;
tester.out() << "For " << eq4 << " --> " << eq6 << ", then " << eq3 << " --> ";
tester.out() << equivSubset(eq4,eq6,eq3) << std::endl;
tester.out() << "For " << eq1 << " --> " << eq2 << ", then " << eq3 << " --> ";
tester.out() << equivSubset(eq1,eq2,eq3) << std::endl;
tester.out() << "------------------------------------" << std::endl;
NewDomain3<Interval<1>, Interval<1>, int>::SliceType_t ba;
// tester.out() << "Created initial slice domain ba = " << ba << std::endl;
ba = NewDomain3<Interval<1>, Interval<1>, int>::combineSlice(ba,eq1,eq1,7);
tester.out() << "After taking slice, ba = " << ba << std::endl;
int retval = tester.results("Domain Calc");
Pooma::finalize();
return retval;
}
int main()
{
{
int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
int* an = ab + sizeof(ab)/sizeof(ab[0]);
typedef test_allocator<MoveOnly> A;
std::deque<MoveOnly, A> c1(A(5));
for (int* p = ab; p < an; ++p)
c1.push_back(MoveOnly(*p));
std::deque<MoveOnly, A> c2(A(5));
for (int* p = ab; p < an; ++p)
c2.push_back(MoveOnly(*p));
std::deque<MoveOnly, A> c3(A(5));
c3 = std::move(c1);
assert(c2 == c3);
assert(c1.size() == 0);
assert(c3.get_allocator() == A(5));
}
{
int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
int* an = ab + sizeof(ab)/sizeof(ab[0]);
typedef test_allocator<MoveOnly> A;
std::deque<MoveOnly, A> c1(A(5));
for (int* p = ab; p < an; ++p)
c1.push_back(MoveOnly(*p));
std::deque<MoveOnly, A> c2(A(5));
for (int* p = ab; p < an; ++p)
c2.push_back(MoveOnly(*p));
std::deque<MoveOnly, A> c3(A(6));
c3 = std::move(c1);
assert(c2 == c3);
assert(c1.size() != 0);
assert(c3.get_allocator() == A(6));
}
{
int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
int* an = ab + sizeof(ab)/sizeof(ab[0]);
typedef other_allocator<MoveOnly> A;
std::deque<MoveOnly, A> c1(A(5));
for (int* p = ab; p < an; ++p)
c1.push_back(MoveOnly(*p));
std::deque<MoveOnly, A> c2(A(5));
for (int* p = ab; p < an; ++p)
c2.push_back(MoveOnly(*p));
std::deque<MoveOnly, A> c3(A(6));
c3 = std::move(c1);
assert(c2 == c3);
assert(c1.size() == 0);
assert(c3.get_allocator() == A(5));
}
{
int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
int* an = ab + sizeof(ab)/sizeof(ab[0]);
typedef min_allocator<MoveOnly> A;
std::deque<MoveOnly, A> c1(A{});
for (int* p = ab; p < an; ++p)
c1.push_back(MoveOnly(*p));
std::deque<MoveOnly, A> c2(A{});
for (int* p = ab; p < an; ++p)
c2.push_back(MoveOnly(*p));
std::deque<MoveOnly, A> c3(A{});
c3 = std::move(c1);
assert(c2 == c3);
assert(c1.size() == 0);
assert(c3.get_allocator() == A());
}
}
void VariableTestFixture::testSimpleExpression() {
Datum six(M_INTEGER, 6);
ConstantVariable c1(six);
Datum five(M_INTEGER, 5);
ConstantVariable c2(five);
// boolean expressions
shared_ptr<ExpressionVariable> e;
e = shared_ptr<ExpressionVariable>(new ExpressionVariable(&c1, &c2, M_IS_EQUAL));
CPPUNIT_ASSERT(!e->getValue().getBool());
e = shared_ptr<ExpressionVariable>(new ExpressionVariable(&c2, &c2, M_IS_EQUAL));
CPPUNIT_ASSERT(e->getValue().getBool());
e = shared_ptr<ExpressionVariable>(new ExpressionVariable(&c1, &c2, M_IS_NOT_EQUAL));
CPPUNIT_ASSERT(e->getValue().getBool());
e = shared_ptr<ExpressionVariable>(new ExpressionVariable(&c1, &c1, M_IS_NOT_EQUAL));
CPPUNIT_ASSERT(!e->getValue().getBool());
e = shared_ptr<ExpressionVariable>(new ExpressionVariable(&c1, &c2, M_IS_GREATER_THAN));
CPPUNIT_ASSERT(e->getValue().getBool());
e = shared_ptr<ExpressionVariable>(new ExpressionVariable(&c2, &c1, M_IS_GREATER_THAN));
CPPUNIT_ASSERT(!e->getValue().getBool());
e = shared_ptr<ExpressionVariable>(new ExpressionVariable(&c1, &c1, M_IS_GREATER_THAN));
CPPUNIT_ASSERT(!e->getValue().getBool());
e = shared_ptr<ExpressionVariable>(new ExpressionVariable(&c1, &c2, M_IS_GREATER_THAN_OR_EQUAL));
CPPUNIT_ASSERT(e->getValue().getBool());
e = shared_ptr<ExpressionVariable>(new ExpressionVariable(&c2, &c1, M_IS_GREATER_THAN_OR_EQUAL));
CPPUNIT_ASSERT(!e->getValue().getBool());
e = shared_ptr<ExpressionVariable>(new ExpressionVariable(&c1, &c1, M_IS_GREATER_THAN_OR_EQUAL));
CPPUNIT_ASSERT(e->getValue().getBool());
e = shared_ptr<ExpressionVariable>(new ExpressionVariable(&c1, &c2, M_IS_LESS_THAN));
CPPUNIT_ASSERT(!e->getValue().getBool());
e = shared_ptr<ExpressionVariable>(new ExpressionVariable(&c2, &c1, M_IS_LESS_THAN));
CPPUNIT_ASSERT(e->getValue().getBool());
e = shared_ptr<ExpressionVariable>(new ExpressionVariable(&c1, &c1, M_IS_LESS_THAN));
CPPUNIT_ASSERT(!e->getValue().getBool());
e = shared_ptr<ExpressionVariable>(new ExpressionVariable(&c1, &c2, M_IS_LESS_THAN_OR_EQUAL));
CPPUNIT_ASSERT(!e->getValue().getBool());
e = shared_ptr<ExpressionVariable>(new ExpressionVariable(&c2, &c1, M_IS_LESS_THAN_OR_EQUAL));
CPPUNIT_ASSERT(e->getValue().getBool());
e = shared_ptr<ExpressionVariable>(new ExpressionVariable(&c1, &c1, M_IS_LESS_THAN_OR_EQUAL));
CPPUNIT_ASSERT(e->getValue().getBool());
// arithmatic expressions
e = shared_ptr<ExpressionVariable>(new ExpressionVariable(&c1, &c2, M_PLUS));
CPPUNIT_ASSERT(e->getValue().getInteger() == (long)(six + five));
e = shared_ptr<ExpressionVariable>(new ExpressionVariable(&c1, &c2, M_MINUS));
CPPUNIT_ASSERT(e->getValue().getInteger() == (long)(six - five));
e = shared_ptr<ExpressionVariable>(new ExpressionVariable(&c1, &c2, M_TIMES));
CPPUNIT_ASSERT(e->getValue().getFloat() == (float)(six * five));
e = shared_ptr<ExpressionVariable>(new ExpressionVariable(&c1, &c2, M_DIVIDE));
CPPUNIT_ASSERT(e->getValue().getFloat() == (double)(six / five));
e = shared_ptr<ExpressionVariable>(new ExpressionVariable(&c1, &c2, M_MOD));
CPPUNIT_ASSERT(e->getValue().getInteger() == (long)(six % five));
e = shared_ptr<ExpressionVariable>(new ExpressionVariable(&c1, &c2, M_INCREMENT));
CPPUNIT_ASSERT(e->getValue().getInteger() == (long)(six + Datum(M_FLOAT,1)));
e = shared_ptr<ExpressionVariable>(new ExpressionVariable(&c1, &c2, M_DECREMENT));
CPPUNIT_ASSERT(e->getValue().getInteger() == (long)(six - Datum(M_FLOAT,1)));
e = shared_ptr<ExpressionVariable>(new ExpressionVariable(&c1, NULL, M_INCREMENT));
CPPUNIT_ASSERT(e->getValue().getInteger() == (long)(six + Datum(M_FLOAT,1)));
e = shared_ptr<ExpressionVariable>(new ExpressionVariable(&c1, NULL, M_DECREMENT));
CPPUNIT_ASSERT(e->getValue().getInteger() == (long)(six - Datum(M_FLOAT,1)));
Datum seven(M_INTEGER, 0x7);
ConstantVariable c3(seven);
Datum eight(M_INTEGER, 0x8);
ConstantVariable c4(eight);
e = shared_ptr<ExpressionVariable>(new ExpressionVariable(&c3, &c4, M_AND));
CPPUNIT_ASSERT(e->getValue().getInteger() == (long)(seven && eight));
e = shared_ptr<ExpressionVariable>(new ExpressionVariable(&c3, &c4, M_OR));
CPPUNIT_ASSERT(e->getValue().getInteger() == (long)(seven || eight));
e = shared_ptr<ExpressionVariable>(new ExpressionVariable(&c3, &c4, M_NOT));
CPPUNIT_ASSERT(e->getValue().getInteger() == (long)(!seven));
e = shared_ptr<ExpressionVariable>(new ExpressionVariable(&c3, NULL, M_NOT));
CPPUNIT_ASSERT(e->getValue().getInteger() == (long)(!seven));
e = shared_ptr<ExpressionVariable>(new ExpressionVariable(&c1, &c2, M_UNARY_MINUS));
CPPUNIT_ASSERT(e->getValue().getInteger() == (long)(six)*-1);
e = shared_ptr<ExpressionVariable>(new ExpressionVariable(&c1, NULL, M_UNARY_MINUS));
CPPUNIT_ASSERT(e->getValue().getInteger() == (long)(six)*-1);
e = shared_ptr<ExpressionVariable>(new ExpressionVariable(&c1, &c2, M_UNARY_PLUS));
CPPUNIT_ASSERT(e->getValue().getInteger() == (long)(six));
e = shared_ptr<ExpressionVariable>(new ExpressionVariable(&c1, NULL, M_UNARY_PLUS));
CPPUNIT_ASSERT(e->getValue().getInteger() == (long)(six));
}
int main() {
ic::Plot::SetHTTStyle();
std::string dir="/vols/cms04/pjd12/invcmssws/CMSSW_7_1_5/src/HiggsAnalysis/CombinedLimit/exocombcards/";
std::vector<Scan> scans;
// scans.push_back({"higgsCombinefullScan.MultiDimFit.mH125.root", "Observed", 1, nullptr});
// scans.push_back({"higgsCombineexpected.MultiDimFit.mH125.root", "Exp. for SM H", 32, nullptr});
// scans.push_back({"higgsCombinenoBBBScan.MultiDimFit.mH125.root", "no bbb syst.", 38, nullptr});
scans.push_back({dir+"higgsCombineCombExp.MultiDimFit.mH125.root", "Exp. for SM H", 1, nullptr});
scans.push_back({dir+"higgsCombineCombObs.MultiDimFit.mH125.root", "Obs. for SM H", 1, nullptr});
TCanvas c1("canvas","canvas");
std::vector<TLine *> lines;
TLegend *leg = new TLegend(0.65,0.75,0.9,0.9,"","brNDC");
unsigned counter = 0;
for (auto & sc : scans) {
TFile f1(sc.file.c_str());
TTree *t1 = dynamic_cast<TTree*>(f1.Get("limit"));
double best1 = 0.0;
TString res;
sc.gr = new TGraph(ExtractGraph(t1, best1));
if(counter==1){
auto x1 = GetCrossings(*(sc.gr), 1.0);
auto x2 = GetCrossings(*(sc.gr), 3.84);
lines.push_back(new TLine(x1[0],0,x1[0],1.0));
lines.back()->SetLineColor(2);
lines.back()->SetLineWidth(2);
lines.push_back(new TLine(x2[0],0,x2[0],3.84));
lines.back()->SetLineColor(2);
lines.back()->SetLineWidth(2);
}
sc.gr->SetLineColor(sc.color);
sc.gr->SetLineWidth(3);
sc.gr->Draw(counter ? "LSAME" : "AL");
TString leg_text = "#splitline{"+sc.label+"}{"+res+"}";
leg->AddEntry(sc.gr, leg_text, "L");
counter++;
}
// c1.cd();
// // g1.Print();
// g1.SetLineColor(1);
// g1.SetLineWidth(2);
// // g1.SetMarkerColor(7);
// g1.Draw("AC");
scans[0].gr->SetMaximum(9);
scans[0].gr->SetMinimum(0.);
scans[0].gr->GetXaxis()->SetRangeUser(0., 0.9);
scans[0].gr->GetXaxis()->SetTitle("BR_{inv}");
scans[0].gr->GetXaxis()->SetTitleOffset(1.1);
scans[0].gr->GetXaxis()->SetNdivisions(1005,true);
scans[0].gr->GetXaxis()->SetLabelSize(0.05);
scans[0].gr->GetYaxis()->SetLabelSize(0.05);
scans[0].gr->GetXaxis()->SetLabelOffset(0.02);
scans[0].gr->GetYaxis()->SetLabelOffset(0.02);
scans[0].gr->GetYaxis()->SetTitle("-2 #Delta ln L");
scans[0].gr->SetLineStyle(2);
scans[0].gr->SetLineColor(1);
leg->SetBorderSize(1);
leg->SetTextFont(42);
leg->SetTextSize(0.03);
leg->SetLineColor(1);
leg->SetLineStyle(1);
leg->SetLineWidth(1);
leg->SetFillColor(0);
leg->SetFillStyle(1001);
leg->Draw();
lines.push_back(new TLine(0.,1,0.9,1.0));
lines.back()->SetLineColor(2);
lines.push_back(new TLine(0.,3.84,0.9,3.84));
lines.back()->SetLineColor(2);
// for (auto l : lines) l->Draw();
DrawCMSLogoTest(&c1,"CMS","preliminary",10);
TLatex lat = TLatex();
lat.SetNDC();
lat.SetTextSize(0.04);
lat.SetTextFont(42);
TLatex lat2 = TLatex();
lat2.SetNDC();
lat2.SetTextSize(0.03);
lat2.SetTextFont(42);
lat.DrawLatex(0.2,0.73,"Combination of all");
lat.DrawLatex(0.2,0.68,"H#rightarrow inv. channels");
c1.Update();
c1.SaveAs("scan.pdf");
return 0;
}
int main(int argc, char* argv[]) {
Matrix G;
Matrix Y;
Matrix Cov;
LoadMatrix("input.mt.g", G);
LoadMatrix("input.mt.y", Y);
LoadMatrix("input.mt.cov", Cov);
Cov.SetColumnLabel(0, "c1");
Cov.SetColumnLabel(1, "c2");
Y.SetColumnLabel(0, "y1");
Y.SetColumnLabel(1, "y2");
Y.SetColumnLabel(2, "y3");
FormulaVector tests;
{
const char* tp1[] = {"y1"};
const char* tc1[] = {"c1"};
std::vector<std::string> p1(tp1, tp1 + 1);
std::vector<std::string> c1(tc1, tc1 + 1);
tests.add(p1, c1);
}
{
const char* tp1[] = {"y2"};
const char* tc1[] = {"c2"};
std::vector<std::string> p1(tp1, tp1 + 1);
std::vector<std::string> c1(tc1, tc1 + 1);
tests.add(p1, c1);
}
{
const char* tp1[] = {"y2"};
const char* tc1[] = {"c1", "c2"};
std::vector<std::string> p1(tp1, tp1 + 1);
std::vector<std::string> c1(tc1, tc1 + 2);
tests.add(p1, c1);
}
{
const char* tp1[] = {"y1"};
const char* tc1[] = {"1"};
std::vector<std::string> p1(tp1, tp1 + 1);
std::vector<std::string> c1(tc1, tc1 + 1);
tests.add(p1, c1);
}
AccurateTimer t;
{
FastMultipleTraitLinearRegressionScoreTest mt(1024);
bool ret = mt.FitNullModel(Cov, Y, tests);
if (ret == false) {
printf("Fit null model failed!\n");
exit(1);
}
ret = mt.AddGenotype(G);
if (ret == false) {
printf("Add covariate failed!\n");
exit(1);
}
ret = mt.TestCovariateBlock();
if (ret == false) {
printf("Test covariate block failed!\n");
exit(1);
}
const Vector& u = mt.GetU(0);
printf("u\t");
Print(u);
printf("\n");
const Vector& v = mt.GetV(0);
printf("v\t");
Print(v);
printf("\n");
const Vector& pval = mt.GetPvalue(0);
printf("pval\t");
Print(pval);
printf("\n");
}
return 0;
}
void tst_QPixmapCache::insert()
{
QPixmap p1(10, 10);
p1.fill(Qt::red);
QPixmap p2(10, 10);
p2.fill(Qt::yellow);
// Calcuate estimated num of items what fits to cache
int estimatedNum = (1024 * QPixmapCache::cacheLimit())
/ ((p1.width() * p1.height() * p1.depth()) / 8);
// Mare sure we will put enough items to reach the cache limit
const int numberOfKeys = estimatedNum + 1000;
// make sure it doesn't explode
for (int i = 0; i < numberOfKeys; ++i)
QPixmapCache::insert("0", p1);
// ditto
for (int j = 0; j < numberOfKeys; ++j)
QPixmapCache::insert(QString::number(j), p1);
int num = 0;
for (int k = 0; k < numberOfKeys; ++k) {
if (QPixmapCache::find(QString::number(k)))
++num;
}
if (QPixmapCache::find("0"))
++num;
QVERIFY(num <= estimatedNum);
QPixmap p3;
QPixmapCache::insert("null", p3);
QPixmap c1(10, 10);
c1.fill(Qt::yellow);
QPixmapCache::insert("custom", c1);
QVERIFY(!c1.isDetached());
QPixmap c2(10, 10);
c2.fill(Qt::red);
QPixmapCache::insert("custom", c2);
//We have deleted the old pixmap in the cache for the same key
QVERIFY(c1.isDetached());
//The int part of the API
// make sure it doesn't explode
QList<QPixmapCache::Key> keys;
for (int i = 0; i < numberOfKeys; ++i)
keys.append(QPixmapCache::insert(p1));
num = 0;
for (int k = 0; k < numberOfKeys; ++k) {
if (QPixmapCache::find(keys.at(k), &p2))
++num;
}
estimatedNum = (1024 * QPixmapCache::cacheLimit())
/ ((p1.width() * p1.height() * p1.depth()) / 8);
QVERIFY(num <= estimatedNum);
}
int FacilityLocation::createConsFacilityActivation(int)
{
int numCons = 0;
VariableHash::iterator vit;
Row::ROWSENSE sense = Row::LESS;
int maxnnz = 2;
double rhs = 0.0;
int colVarX, colVarY, colVarZ;
for (vit = vHash[Variable::V_X].begin(); vit != vHash[Variable::V_X].end(); ++vit)
{
colVarX = vit->second;
Arc arc = vit->first.getArc();
Vertex router = vit->first.getArc().getHead();
Vertex client = vit->first.getArc().getTail();
Constraint c(maxnnz, sense, rhs);
c.setType(Constraint::C_FACILITY_ACTIVATION);
c.setClass(1);
c.setArc(arc);
Variable y;
y.setType(Variable::V_Y);
y.setVertex1(router);
VariableHash::iterator aux = vHash[Variable::V_Y].find(y);
if (aux != vHash[Variable::V_Y].end())
{
colVarY = aux->second;
c.rowAddVar(colVarX, 1.0);
c.rowAddVar(colVarY, -1.0);
}
if (c.getRowNnz() > 0)
{
bool isInserted = addRow(&c);
if (isInserted)
{
c.setRowIdx(getNRows() - 1);
cHash[c] = c.getRowIdx();
numCons++;
}
}
}
for (vit = vHash[Variable::V_Z].begin(); vit != vHash[Variable::V_Z].end(); ++vit)
{
colVarZ = vit->second;
Arc arc = vit->first.getArc();
Vertex head = vit->first.getArc().getHead();
Vertex tail = vit->first.getArc().getTail();
Constraint c1(maxnnz, sense, rhs);
c1.setType(Constraint::C_FACILITY_ACTIVATION);
c1.setClass(2);
c1.setArc(arc);
Variable yHead;
yHead.setType(Variable::V_Y);
yHead.setVertex1(head);
VariableHash::iterator aux = vHash[Variable::V_Y].find(yHead);
if (aux != vHash[Variable::V_Y].end())
{
colVarY = aux->second;
c1.rowAddVar(colVarZ, 1.0);
c1.rowAddVar(colVarY, -1.0);
}
if (c1.getRowNnz() > 0)
{
bool isInserted = addRow(&c1);
if (isInserted)
{
c1.setRowIdx(getNRows() - 1);
cHash[c1] = c1.getRowIdx();
numCons++;
}
}
Constraint c2(maxnnz, sense, rhs);
c2.setType(Constraint::C_FACILITY_ACTIVATION);
c2.setClass(2);
c2.setArc(arc.reverse());
Variable yTail;
yTail.setType(Variable::V_Y);
yTail.setVertex1(tail);
aux = vHash[Variable::V_Y].find(yTail);
if (aux != vHash[Variable::V_Y].end())
{
colVarY = aux->second;
c2.rowAddVar(colVarZ, 1.0);
c2.rowAddVar(colVarY, -1.0);
}
if (c2.getRowNnz() > 0)
{
bool isInserted = addRow(&c2);
if (isInserted)
{
c2.setRowIdx(getNRows() - 1);
cHash[c2] = c2.getRowIdx();
numCons++;
}
}
}
return numCons;
}
int main()
{
{
std::vector<int> v(100);
std::vector<int>::iterator i = v.insert(v.cbegin() + 10, 5, 1);
assert(v.size() == 105);
assert(is_contiguous_container_asan_correct(v));
assert(i == v.begin() + 10);
int j;
for (j = 0; j < 10; ++j)
assert(v[j] == 0);
for (; j < 15; ++j)
assert(v[j] == 1);
for (++j; j < 105; ++j)
assert(v[j] == 0);
}
{
std::vector<int, stack_allocator<int, 300> > v(100);
std::vector<int, stack_allocator<int, 300> >::iterator i = v.insert(v.cbegin() + 10, 5, 1);
assert(v.size() == 105);
assert(is_contiguous_container_asan_correct(v));
assert(i == v.begin() + 10);
int j;
for (j = 0; j < 10; ++j)
assert(v[j] == 0);
for (; j < 15; ++j)
assert(v[j] == 1);
for (++j; j < 105; ++j)
assert(v[j] == 0);
}
#if _LIBCPP_DEBUG >= 1
{
std::vector<int> c1(100);
std::vector<int> c2;
std::vector<int>::iterator i = c1.insert(c2.cbegin() + 10, 5, 1);
assert(false);
}
#endif
#if __cplusplus >= 201103L
{
std::vector<int, min_allocator<int>> v(100);
std::vector<int, min_allocator<int>>::iterator i = v.insert(v.cbegin() + 10, 5, 1);
assert(v.size() == 105);
assert(is_contiguous_container_asan_correct(v));
assert(i == v.begin() + 10);
int j;
for (j = 0; j < 10; ++j)
assert(v[j] == 0);
for (; j < 15; ++j)
assert(v[j] == 1);
for (++j; j < 105; ++j)
assert(v[j] == 0);
}
{
std::vector<int, min_allocator<int>> v(100);
std::vector<int, min_allocator<int>>::iterator i = v.insert(v.cbegin() + 10, 5, 1);
assert(v.size() == 105);
assert(is_contiguous_container_asan_correct(v));
assert(i == v.begin() + 10);
int j;
for (j = 0; j < 10; ++j)
assert(v[j] == 0);
for (; j < 15; ++j)
assert(v[j] == 1);
for (++j; j < 105; ++j)
assert(v[j] == 0);
}
#if _LIBCPP_DEBUG >= 1
{
std::vector<int, min_allocator<int>> c1(100);
std::vector<int, min_allocator<int>> c2;
std::vector<int, min_allocator<int>>::iterator i = c1.insert(c2.cbegin() + 10, 5, 1);
assert(false);
}
#endif
#endif
}
void yieldVcent(const char* inName=
"links/P01hi.minbias.2000.hist/hianalysis_1000.hist.root",
const char* psDir="ps",
int cut = 1,
const char* outDir="./",
const char* more = "west",
float extraValue = 0)
{
cout << "--------------------------" << endl;
cout << "in name=" << inName << endl
<< "ps dir=" << psDir << endl
<< "cut=" << cut << endl;
cout << "--------------------------" << endl;
inRoot = new TFile(inName);
if(!inRoot){
cout << "cannot find the infile" << endl;
return;
}
TCanvas c1("c1","c1",400,500);
TString sName,sTitle; TH1* h1a,*h1b; TH3* h3a, *h3b; TH2* h2a,*h2b;
int nSlice=9;
//---------------------------------------------------
// zdc cent
int zdcMin[]={0,5,10,20,30,40,50,60,70,80};
int zdcMax[]={5,10,20,30,40,50,60,70,80,100};
gStyle->SetOptLogy(1); gStyle->SetOptStat(0);
sprintf(name,"raw pt yield, zdc slices (cut %d)",cut);
Divide(&c1,3,3,name,inName);
h2a=(TH2*)inRoot.Get("Plus.h2ZDCCentralityPtPr");
h2b=(TH2*)inRoot.Get("Minus.h2ZDCCentralityPtPr");
for(int i=1; i<=nSlice; i++){
c1.cd(i);
sprintf(name,"zdc%d%s",i,sPM[0]);
h1a=h2a->ProjectionY(name,i,i,"e");
sprintf(name,"zdc%d%s",i,sPM[1]);
h1b=h2b->ProjectionY(name,i,i,"e");
h1a->SetMarkerSize(0.5); h1b->SetMarkerSize(0.5);
h1a->SetMarkerStyle(4); h1b->SetMarkerStyle(8);
sprintf(title,"zdc cent %d (%d-%d %)",
h2a->GetXaxis()->GetBinCenter(i),zdcMin[i-1],zdcMax[i-1]);
h1a->SetTitle(title); SetRange(h1a->GetXaxis(),1.5,6);
//h1a->SetMinimum(0);
h1a->Draw(); h1b->Draw("same");
printHighPtYield(h1a,h1b);
}
Print(&c1,psDir,"yieldPtZdcSlices");
// flow cent
gStyle->SetOptLogy(1); gStyle->SetOptStat(0);
sprintf(name,"raw pt yield, flow slices (cut %d)",cut);
Divide(&c1,3,3,name,inName);
h2a=(TH2*)inRoot.Get("Plus.h2CentralityPtPr");
h2b=(TH2*)inRoot.Get("Minus.h2CentralityPtPr");
for(int i=1; i<=nSlice; i++){
c1.cd(i);
sprintf(name,"flow%d%s",i,sPM[0]);
h1a=h2a->ProjectionY(name,i,i,"e");
sprintf(name,"flow%d%s",i,sPM[1]);
h1b=h2b->ProjectionY(name,i,i,"e");
h1a->SetMarkerStyle(4); h1b->SetMarkerStyle(8);
h1a->SetMarkerSize(0.5); h1b->SetMarkerSize(0.5);
sprintf(title,"flow cent %d",h2a->GetXaxis()->GetBinCenter(i));
h1a->SetTitle(title); SetRange(h1a->GetXaxis(),1.5,6);
//h1a->SetMinimum(0);
h1a->Draw(); h1b->Draw("same");
printHighPtYield(h1a,h1b);
}
Print(&c1,psDir,"yieldPtFlowSlices");
}
int main(int argc, char *argv[]) {
long seed = time(NULL);
srand48(seed);
SetSeed(to_ZZ(seed));
unsigned p = 2027;
unsigned g = 3;
unsigned logQ = 120;
FHEcontext context(p-1, logQ, p, g);
activeContext = &context;
context.SetUpSIContext();
FHESISecKey secretKey(context);
const FHESIPubKey &publicKey(secretKey);
KeySwitchSI keySwitch(secretKey);
long phim = context.zMstar.phiM();
long numSlots = context.GetPlaintextSpace().GetTotalSlots();
long rotAmt = rand() % numSlots;
long rotDeg = 1;
for (int i = 0; i < rotAmt; i++) {
rotDeg *= context.Generator();
rotDeg %= context.zMstar.M();
}
KeySwitchSI automorphKeySwitch(secretKey, rotDeg);
Plaintext p0, p1, p2, p3;
randomizePlaintext(p0, phim, p);
randomizePlaintext(p1, phim, p);
randomizePlaintext(p2, phim, p);
randomizePlaintext(p3, phim, p);
Plaintext const1, const2;
randomizePlaintext(const1, phim, p);
randomizePlaintext(const2, phim, p);
Ciphertext c0(publicKey);
Ciphertext c1(publicKey);
Ciphertext c2(publicKey);
Ciphertext c3(publicKey);
publicKey.Encrypt(c0, p0);
publicKey.Encrypt(c1, p1);
publicKey.Encrypt(c2, p2);
publicKey.Encrypt(c3, p3);
p1 *= p2;
p0 += const1;
p2 *= const2;
p3 >>= rotAmt;
p1 *= -1;
p3 *= p2;
p0 -= p3;
c1 *= c2;
keySwitch.ApplyKeySwitch(c1);
c0 += const1.message;
c2 *= const2.message;
c3 >>= rotDeg;
automorphKeySwitch.ApplyKeySwitch(c3);
c1 *= -1;
c3 *= c2;
keySwitch.ApplyKeySwitch(c3);
Ciphertext tmp(c3);
tmp *= -1;
c0 += tmp;
Plaintext pp0, pp1, pp2, pp3;
secretKey.Decrypt(pp0, c0);
secretKey.Decrypt(pp1, c1);
secretKey.Decrypt(pp2, c2);
secretKey.Decrypt(pp3, c3);
if (!(pp0 == p0)) cerr << "oops 0" << endl;
if (!(pp1 == p1)) cerr << "oops 1" << endl;
if (!(pp2 == p2)) cerr << "oops 2" << endl;
if (!(pp3 == p3)) cerr << "oops 3" << endl;
cout << "All tests finished." << endl;
}
void EditTSCtrl::renderCameraAxis()
{
GFXDEBUGEVENT_SCOPE( Editor_renderCameraAxis, ColorI::WHITE );
static MatrixF sRotMat(EulerF( (M_PI_F / -2.0f), 0.0f, 0.0f));
MatrixF camMat = mLastCameraQuery.cameraMatrix;
camMat.mul(sRotMat);
camMat.inverse();
MatrixF axis;
axis.setColumn(0, Point3F(1, 0, 0));
axis.setColumn(1, Point3F(0, 0, 1));
axis.setColumn(2, Point3F(0, -1, 0));
axis.mul(camMat);
Point3F forwardVec, upVec, rightVec;
axis.getColumn( 2, &forwardVec );
axis.getColumn( 1, &upVec );
axis.getColumn( 0, &rightVec );
Point2I pos = getPosition();
F32 offsetx = pos.x + 20.0;
F32 offsety = pos.y + getExtent().y - 42.0; // Take the status bar into account
F32 scale = 15.0;
// Generate correct drawing order
ColorI c1(255,0,0);
ColorI c2(0,255,0);
ColorI c3(0,0,255);
ColorI tc;
Point3F *p1, *p2, *p3, *tp;
p1 = &rightVec;
p2 = &upVec;
p3 = &forwardVec;
if(p3->y > p2->y)
{
tp = p2; tc = c2;
p2 = p3; c2 = c3;
p3 = tp; c3 = tc;
}
if(p2->y > p1->y)
{
tp = p1; tc = c1;
p1 = p2; c1 = c2;
p2 = tp; c2 = tc;
}
PrimBuild::begin( GFXLineList, 6 );
//*** Axis 1
PrimBuild::color(c1);
PrimBuild::vertex3f(offsetx, offsety, 0);
PrimBuild::vertex3f(offsetx+p1->x*scale, offsety-p1->z*scale, 0);
//*** Axis 2
PrimBuild::color(c2);
PrimBuild::vertex3f(offsetx, offsety, 0);
PrimBuild::vertex3f(offsetx+p2->x*scale, offsety-p2->z*scale, 0);
//*** Axis 3
PrimBuild::color(c3);
PrimBuild::vertex3f(offsetx, offsety, 0);
PrimBuild::vertex3f(offsetx+p3->x*scale, offsety-p3->z*scale, 0);
PrimBuild::end();
}
void test_basic_template(
ForwardIterator first,ForwardIterator last
BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Flyweight))
{
typedef typename Flyweight::value_type value_type;
ForwardIterator it;
for(it=first;it!=last;++it){
/* construct/copy/destroy */
Flyweight f1(*it);
Flyweight f2;
Flyweight c1(f1);
const Flyweight c2(static_cast<const Flyweight&>(f2));
value_type v1(*it);
boost::value_initialized<value_type> v2;
BOOST_TEST(f1.get_key()==*it);
BOOST_TEST((f1==f2)==(f1.get()==v2.data()));
BOOST_TEST(f1==c1);
BOOST_TEST(f2==c2);
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
Flyweight cr1(std::move(c1));
Flyweight cr2(std::move(c2));
BOOST_TEST(f1==cr1);
BOOST_TEST(f2==cr2);
#endif
#if !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX)
/* testcase for https://svn.boost.org/trac/boost/ticket/10439 */
Flyweight f3={};
BOOST_TEST(f3==f2);
#endif
f1=f1;
BOOST_TEST(f1==f1);
c1=f2;
BOOST_TEST(c1==f2);
c1=f1;
BOOST_TEST(c1==f1);
/* convertibility to underlying type */
BOOST_TEST(f1.get()==v1);
/* identity of reference */
BOOST_TEST(&f1.get()==&c1.get());
/* modifiers */
f1.swap(f1);
BOOST_TEST(f1==c1);
f1.swap(f2);
BOOST_TEST(f1==c2);
BOOST_TEST(f2==c1);
boost::flyweights::swap(f1,f2);
BOOST_TEST(f1==c1);
BOOST_TEST(f2==c2);
/* specialized algorithms */
std::ostringstream oss1;
oss1<<f1;
std::ostringstream oss2;
oss2<<f1.get();
BOOST_TEST(oss1.str()==oss2.str());
#if !defined(BOOST_FLYWEIGHT_DISABLE_HASH_SUPPORT)
/* hash support */
BOOST_TEST(boost::hash<Flyweight>()(f1)==boost::hash<Flyweight>()(c1));
BOOST_TEST(boost::hash<Flyweight>()(f1)==
boost::hash<const value_type*>()(&f1.get()));
#if !defined(BOOST_NO_CXX11_HDR_FUNCTIONAL)
BOOST_TEST(std::hash<Flyweight>()(f1)==std::hash<Flyweight>()(c1));
BOOST_TEST(std::hash<Flyweight>()(f1)==
std::hash<const value_type*>()(&f1.get()));
#endif
#endif
}
}
bool QQuickSvgParser::parsePathDataFast(const QString &dataStr, QPainterPath &path)
{
qreal x0 = 0, y0 = 0; // starting point
qreal x = 0, y = 0; // current point
char lastMode = 0;
QPointF ctrlPt;
const QChar *str = dataStr.constData();
const QChar *end = str + dataStr.size();
while (str != end) {
while (str->isSpace())
++str;
QChar pathElem = *str;
++str;
QChar endc = *end;
*const_cast<QChar *>(end) = 0; // parseNumbersArray requires 0-termination that QStringRef cannot guarantee
QVarLengthArray<qreal, 8> arg;
parseNumbersArray(str, arg);
*const_cast<QChar *>(end) = endc;
if (pathElem == QLatin1Char('z') || pathElem == QLatin1Char('Z'))
arg.append(0);//dummy
const qreal *num = arg.constData();
int count = arg.count();
while (count > 0) {
qreal offsetX = x; // correction offsets
qreal offsetY = y; // for relative commands
switch (pathElem.unicode()) {
case 'm': {
if (count < 2) {
num++;
count--;
break;
}
x = x0 = num[0] + offsetX;
y = y0 = num[1] + offsetY;
num += 2;
count -= 2;
path.moveTo(x0, y0);
// As per 1.2 spec 8.3.2 The "moveto" commands
// If a 'moveto' is followed by multiple pairs of coordinates without explicit commands,
// the subsequent pairs shall be treated as implicit 'lineto' commands.
pathElem = QLatin1Char('l');
}
break;
case 'M': {
if (count < 2) {
num++;
count--;
break;
}
x = x0 = num[0];
y = y0 = num[1];
num += 2;
count -= 2;
path.moveTo(x0, y0);
// As per 1.2 spec 8.3.2 The "moveto" commands
// If a 'moveto' is followed by multiple pairs of coordinates without explicit commands,
// the subsequent pairs shall be treated as implicit 'lineto' commands.
pathElem = QLatin1Char('L');
}
break;
case 'z':
case 'Z': {
x = x0;
y = y0;
count--; // skip dummy
num++;
path.closeSubpath();
}
break;
case 'l': {
if (count < 2) {
num++;
count--;
break;
}
x = num[0] + offsetX;
y = num[1] + offsetY;
num += 2;
count -= 2;
path.lineTo(x, y);
}
break;
case 'L': {
if (count < 2) {
num++;
count--;
break;
}
x = num[0];
y = num[1];
num += 2;
count -= 2;
path.lineTo(x, y);
}
break;
case 'h': {
x = num[0] + offsetX;
num++;
count--;
path.lineTo(x, y);
}
break;
case 'H': {
x = num[0];
num++;
count--;
path.lineTo(x, y);
}
break;
case 'v': {
y = num[0] + offsetY;
num++;
count--;
path.lineTo(x, y);
}
break;
case 'V': {
y = num[0];
num++;
count--;
path.lineTo(x, y);
}
break;
case 'c': {
if (count < 6) {
num += count;
count = 0;
break;
}
QPointF c1(num[0] + offsetX, num[1] + offsetY);
QPointF c2(num[2] + offsetX, num[3] + offsetY);
QPointF e(num[4] + offsetX, num[5] + offsetY);
num += 6;
count -= 6;
path.cubicTo(c1, c2, e);
ctrlPt = c2;
x = e.x();
y = e.y();
break;
}
case 'C': {
if (count < 6) {
num += count;
count = 0;
break;
}
QPointF c1(num[0], num[1]);
QPointF c2(num[2], num[3]);
QPointF e(num[4], num[5]);
num += 6;
count -= 6;
path.cubicTo(c1, c2, e);
ctrlPt = c2;
x = e.x();
y = e.y();
break;
}
case 's': {
if (count < 4) {
num += count;
count = 0;
break;
}
QPointF c1;
if (lastMode == 'c' || lastMode == 'C' ||
lastMode == 's' || lastMode == 'S')
c1 = QPointF(2*x-ctrlPt.x(), 2*y-ctrlPt.y());
else
c1 = QPointF(x, y);
QPointF c2(num[0] + offsetX, num[1] + offsetY);
QPointF e(num[2] + offsetX, num[3] + offsetY);
num += 4;
count -= 4;
path.cubicTo(c1, c2, e);
ctrlPt = c2;
x = e.x();
y = e.y();
break;
}
case 'S': {
if (count < 4) {
num += count;
count = 0;
break;
}
QPointF c1;
if (lastMode == 'c' || lastMode == 'C' ||
lastMode == 's' || lastMode == 'S')
c1 = QPointF(2*x-ctrlPt.x(), 2*y-ctrlPt.y());
else
c1 = QPointF(x, y);
QPointF c2(num[0], num[1]);
QPointF e(num[2], num[3]);
num += 4;
count -= 4;
path.cubicTo(c1, c2, e);
ctrlPt = c2;
x = e.x();
y = e.y();
break;
}
case 'q': {
if (count < 4) {
num += count;
count = 0;
break;
}
QPointF c(num[0] + offsetX, num[1] + offsetY);
QPointF e(num[2] + offsetX, num[3] + offsetY);
num += 4;
count -= 4;
path.quadTo(c, e);
ctrlPt = c;
x = e.x();
y = e.y();
break;
}
case 'Q': {
if (count < 4) {
num += count;
count = 0;
break;
}
QPointF c(num[0], num[1]);
QPointF e(num[2], num[3]);
num += 4;
count -= 4;
path.quadTo(c, e);
ctrlPt = c;
x = e.x();
y = e.y();
break;
}
case 't': {
if (count < 2) {
num += count;
count = 0;
break;
}
QPointF e(num[0] + offsetX, num[1] + offsetY);
num += 2;
count -= 2;
QPointF c;
if (lastMode == 'q' || lastMode == 'Q' ||
lastMode == 't' || lastMode == 'T')
c = QPointF(2*x-ctrlPt.x(), 2*y-ctrlPt.y());
else
c = QPointF(x, y);
path.quadTo(c, e);
ctrlPt = c;
x = e.x();
y = e.y();
break;
}
case 'T': {
if (count < 2) {
num += count;
count = 0;
break;
}
QPointF e(num[0], num[1]);
num += 2;
count -= 2;
QPointF c;
if (lastMode == 'q' || lastMode == 'Q' ||
lastMode == 't' || lastMode == 'T')
c = QPointF(2*x-ctrlPt.x(), 2*y-ctrlPt.y());
else
c = QPointF(x, y);
path.quadTo(c, e);
ctrlPt = c;
x = e.x();
y = e.y();
break;
}
case 'a': {
if (count < 7) {
num += count;
count = 0;
break;
}
qreal rx = (*num++);
qreal ry = (*num++);
qreal xAxisRotation = (*num++);
qreal largeArcFlag = (*num++);
qreal sweepFlag = (*num++);
qreal ex = (*num++) + offsetX;
qreal ey = (*num++) + offsetY;
count -= 7;
qreal curx = x;
qreal cury = y;
pathArc(path, rx, ry, xAxisRotation, int(largeArcFlag),
int(sweepFlag), ex, ey, curx, cury);
x = ex;
y = ey;
}
break;
case 'A': {
if (count < 7) {
num += count;
count = 0;
break;
}
qreal rx = (*num++);
qreal ry = (*num++);
qreal xAxisRotation = (*num++);
qreal largeArcFlag = (*num++);
qreal sweepFlag = (*num++);
qreal ex = (*num++);
qreal ey = (*num++);
count -= 7;
qreal curx = x;
qreal cury = y;
pathArc(path, rx, ry, xAxisRotation, int(largeArcFlag),
int(sweepFlag), ex, ey, curx, cury);
x = ex;
y = ey;
}
break;
default:
return false;
}
lastMode = pathElem.toLatin1();
}
}
return true;
}
void plot(const char* type = "eps")
{
gROOT->ProcessLine(".x ../../style.C");
TFile *f = new TFile("../../SharedRootFiles/Osc.root");
TH1D *data[6];
TH1D *predOsc[6];
TH1D *acc[6];
TH1D *li9[6];
TH1D *fsn[6];
TH1D *afn[6];
TH1D *amc[6];
data[0] = (TH1D*)f->Get("ibd_spectrum_site1_det1");
data[1] = (TH1D*)f->Get("ibd_spectrum_site1_det2");
data[2] = (TH1D*)f->Get("ibd_spectrum_site2_det1");
data[3] = (TH1D*)f->Get("ibd_spectrum_site4_det1");
data[4] = (TH1D*)f->Get("ibd_spectrum_site4_det2");
data[5] = (TH1D*)f->Get("ibd_spectrum_site4_det3");
predOsc[0] = (TH1D*)f->Get("total_spectrum_expected_AD1");
predOsc[1] = (TH1D*)f->Get("total_spectrum_expected_AD2");
predOsc[2] = (TH1D*)f->Get("total_spectrum_expected_AD3");
predOsc[3] = (TH1D*)f->Get("total_spectrum_expected_AD4");
predOsc[4] = (TH1D*)f->Get("total_spectrum_expected_AD5");
predOsc[5] = (TH1D*)f->Get("total_spectrum_expected_AD6");
acc[0] = (TH1D*)f->Get("acc_spectrum_expected_AD1");
acc[1] = (TH1D*)f->Get("acc_spectrum_expected_AD2");
acc[2] = (TH1D*)f->Get("acc_spectrum_expected_AD3");
acc[3] = (TH1D*)f->Get("acc_spectrum_expected_AD4");
acc[4] = (TH1D*)f->Get("acc_spectrum_expected_AD5");
acc[5] = (TH1D*)f->Get("acc_spectrum_expected_AD6");
li9[0] = (TH1D*)f->Get("li9he8_spectrum_expected_AD1");
li9[1] = (TH1D*)f->Get("li9he8_spectrum_expected_AD2");
li9[2] = (TH1D*)f->Get("li9he8_spectrum_expected_AD3");
li9[3] = (TH1D*)f->Get("li9he8_spectrum_expected_AD4");
li9[4] = (TH1D*)f->Get("li9he8_spectrum_expected_AD5");
li9[5] = (TH1D*)f->Get("li9he8_spectrum_expected_AD6");
fsn[0] = (TH1D*)f->Get("fastn_spectrum_expected_AD1");
fsn[1] = (TH1D*)f->Get("fastn_spectrum_expected_AD2");
fsn[2] = (TH1D*)f->Get("fastn_spectrum_expected_AD3");
fsn[3] = (TH1D*)f->Get("fastn_spectrum_expected_AD4");
fsn[4] = (TH1D*)f->Get("fastn_spectrum_expected_AD5");
fsn[5] = (TH1D*)f->Get("fastn_spectrum_expected_AD6");
amc[0] = (TH1D*)f->Get("amc_spectrum_expected_AD1");
amc[1] = (TH1D*)f->Get("amc_spectrum_expected_AD2");
amc[2] = (TH1D*)f->Get("amc_spectrum_expected_AD3");
amc[3] = (TH1D*)f->Get("amc_spectrum_expected_AD4");
amc[4] = (TH1D*)f->Get("amc_spectrum_expected_AD5");
amc[5] = (TH1D*)f->Get("amc_spectrum_expected_AD6");
afn[0] = (TH1D*)f->Get("alphan_spectrum_expected_AD1");
afn[1] = (TH1D*)f->Get("alphan_spectrum_expected_AD2");
afn[2] = (TH1D*)f->Get("alphan_spectrum_expected_AD3");
afn[3] = (TH1D*)f->Get("alphan_spectrum_expected_AD4");
afn[4] = (TH1D*)f->Get("alphan_spectrum_expected_AD5");
afn[5] = (TH1D*)f->Get("alphan_spectrum_expected_AD6");
TH1D *data_site1 = data[0]->Clone("data_site1");
data_site1->GetXaxis()->SetTitle("Prompt Energy [MeV]");
data_site1->GetYaxis()->SetTitle("Events / 50KeV");
data_site1->SetTitle("IBDs at EH1");
TH1D *data_site2 = data[2]->Clone("data_site2");
data_site2->GetXaxis()->SetTitle("Prompt Energy [MeV]");
data_site2->GetYaxis()->SetTitle("Events / 50KeV");
data_site2->SetTitle("IBDs at EH2");
TH1D *data_site3 = data[3]->Clone("data_site3");
data_site3->GetXaxis()->SetTitle("Prompt Energy [MeV]");
data_site3->GetYaxis()->SetTitle("Events / 50KeV");
data_site3->SetTitle("IBDs at EH3");
TH1D *pred_site1 = predOsc[0]->Clone("pred_site1");
THStack *hs_site1 = new THStack("hs_site1", "");
TH1D *acc_site1 = acc[0]->Clone("acc_site1");
TH1D *li9_site1 = li9[0]->Clone("li9_site1");
TH1D *fsn_site1 = fsn[0]->Clone("fsn_site1");
TH1D *amc_site1 = amc[0]->Clone("amc_site1");
TH1D *afn_site1 = afn[0]->Clone("afn_site1");
TH1D *pred_site2 = predOsc[2]->Clone("pred_site2");
THStack *hs_site2 = new THStack("hs_site2", "");
TH1D *acc_site2 = acc[2]->Clone("acc_site2");
TH1D *li9_site2 = li9[2]->Clone("li9_site2");
TH1D *fsn_site2 = fsn[2]->Clone("fsn_site2");
TH1D *amc_site2 = amc[2]->Clone("amc_site2");
TH1D *afn_site2 = afn[2]->Clone("afn_site2");
TH1D *pred_site3 = predOsc[3]->Clone("pred_site3");
THStack *hs_site3 = new THStack("hs_site3", "");
TH1D *acc_site3 = acc[3]->Clone("acc_site3");
TH1D *li9_site3 = li9[3]->Clone("li9_site3");
TH1D *fsn_site3 = fsn[3]->Clone("fsn_site3");
TH1D *amc_site3 = amc[3]->Clone("amc_site3");
TH1D *afn_site3 = afn[3]->Clone("afn_site3");
data_site1->Reset();
pred_site1->Reset();
acc_site1->Reset();
li9_site1->Reset();
fsn_site1->Reset();
amc_site1->Reset();
afn_site1->Reset();
data_site2->Reset();
pred_site2->Reset();
acc_site2->Reset();
li9_site2->Reset();
fsn_site2->Reset();
amc_site2->Reset();
afn_site2->Reset();
data_site3->Reset();
pred_site3->Reset();
acc_site3->Reset();
li9_site3->Reset();
fsn_site3->Reset();
amc_site3->Reset();
afn_site3->Reset();
pred_site1->SetLineColor(2);
pred_site1->SetMarkerColor(2);
acc_site1->SetLineColor(9);
acc_site1->SetMarkerColor(9);
acc_site1->SetFillColor(9);
li9_site1->SetLineColor(5);
li9_site1->SetMarkerColor(5);
li9_site1->SetFillColor(5);
fsn_site1->SetLineColor(6);
fsn_site1->SetMarkerColor(6);
fsn_site1->SetFillColor(6);
amc_site1->SetLineColor(7);
amc_site1->SetMarkerColor(7);
amc_site1->SetFillColor(7);
afn_site1->SetLineColor(8);
afn_site1->SetLineColor(8);
afn_site1->SetFillColor(8);
pred_site2->SetLineColor(2);
pred_site2->SetMarkerColor(2);
acc_site2->SetLineColor(9);
acc_site2->SetMarkerColor(9);
acc_site2->SetFillColor(9);
li9_site2->SetLineColor(5);
li9_site2->SetMarkerColor(5);
li9_site2->SetFillColor(5);
fsn_site2->SetLineColor(6);
fsn_site2->SetMarkerColor(6);
fsn_site2->SetFillColor(6);
amc_site2->SetLineColor(7);
amc_site2->SetMarkerColor(7);
amc_site2->SetFillColor(7);
afn_site2->SetLineColor(8);
afn_site2->SetLineColor(8);
afn_site2->SetFillColor(8);
pred_site3->SetLineColor(2);
pred_site3->SetMarkerColor(2);
acc_site3->SetLineColor(9);
acc_site3->SetMarkerColor(9);
acc_site3->SetFillColor(9);
li9_site3->SetLineColor(5);
li9_site3->SetMarkerColor(5);
li9_site3->SetFillColor(5);
fsn_site3->SetLineColor(6);
fsn_site3->SetMarkerColor(6);
fsn_site3->SetFillColor(6);
amc_site3->SetLineColor(7);
amc_site3->SetMarkerColor(7);
amc_site3->SetFillColor(7);
afn_site3->SetLineColor(8);
afn_site3->SetLineColor(8);
afn_site3->SetFillColor(8);
for (int i=0; i<2; i++) {
data_site1->Add(data[i]);
pred_site1->Add(predOsc[i]);
acc_site1->Add(acc[i]);
li9_site1->Add(li9[i]);
fsn_site1->Add(fsn[i]);
amc_site1->Add(amc[i]);
afn_site1->Add(afn[i]);
}
for (int i=2; i<3; i++) {
data_site2->Add(data[i]);
pred_site2->Add(predOsc[i]);
acc_site2->Add(acc[i]);
li9_site2->Add(li9[i]);
fsn_site2->Add(fsn[i]);
amc_site2->Add(amc[i]);
afn_site2->Add(afn[i]);
}
for (int i=3; i<6; i++) {
data_site3->Add(data[i]);
pred_site3->Add(predOsc[i]);
acc_site3->Add(acc[i]);
li9_site3->Add(li9[i]);
fsn_site3->Add(fsn[i]);
amc_site3->Add(amc[i]);
afn_site3->Add(afn[i]);
}
hs_site1->Add(fsn_site1);
hs_site1->Add(afn_site1);
hs_site1->Add(amc_site1);
hs_site1->Add(li9_site1);
hs_site1->Add(acc_site1);
hs_site2->Add(fsn_site2);
hs_site2->Add(afn_site2);
hs_site2->Add(amc_site2);
hs_site2->Add(li9_site2);
hs_site2->Add(acc_site2);
hs_site3->Add(fsn_site3);
hs_site3->Add(afn_site3);
hs_site3->Add(amc_site3);
hs_site3->Add(li9_site3);
hs_site3->Add(acc_site3);
TCanvas c1("c1", "c1", 800, 800);
TPad *can_1 = new TPad("can_1", "can_1",0, 0.66, 1, 0.99);
TPad *can_2 = new TPad("can_2", "can_2",0, 0.33, 1, 0.66);
TPad *can_3 = new TPad("can_3", "can_3",0, 0, 1, 0.33);
can_1->Draw();
can_1->cd();
can_1->SetBottomMargin(1e-05);
can_1->SetFrameBorderMode(0);
can_1->SetBorderMode(0);
data_site1->Draw();
data_site1->SetTitle("");
hs_site1->Draw("same");
data_site1->Draw("same");
// pred_site1->Draw("same");
data_site1->GetXaxis()->SetLabelSize(0.09);
data_site1->GetYaxis()->SetNdivisions(508);
data_site1->GetYaxis()->SetTitleSize(0.08);
data_site1->GetYaxis()->SetLabelSize(0.08);
data_site1->GetYaxis()->SetTitleOffset(0.6);
data_site1->GetYaxis()->CenterTitle(true);
TLegend leg(0.65,0.85-0.20,0.85,0.85);
leg.AddEntry(data_site1, " EH1", "lp");
leg.AddEntry(acc_site1, " Acc. Bkgd", "f");
leg.SetFillColor(kWhite);
leg.Draw();
can_1->Modified();
c1.cd();
can_2->Draw();
can_2->cd();
can_2->SetTopMargin(1e-05);
can_2->SetBottomMargin(1e-05);
can_2->SetFrameBorderMode(0);
can_2->SetBorderMode(0);
data_site2->Draw();
hs_site2->Draw("same");
data_site2->SetTitle("");
// data_site2->Draw("same");
// pred_site2->Draw("same");
data_site2->GetXaxis()->SetLabelSize(0.09);
data_site2->GetYaxis()->SetNdivisions(508);
data_site2->GetYaxis()->SetTitleSize(0.08);
data_site2->GetYaxis()->SetLabelSize(0.08);
data_site2->GetYaxis()->SetTitleOffset(0.6);
data_site2->GetYaxis()->CenterTitle(true);
TLegend leg2(0.65,0.85-0.20,0.85,0.85);
leg2.AddEntry(data_site2, " EH2", "lp");
leg2.AddEntry(acc_site2, " Acc. Bkgd", "f");
leg2.SetFillColor(kWhite);
leg2.Draw();
can_2->Modified();
c1.cd();
can_3->Draw();
can_3->cd();
can_3->SetTopMargin(1e-05);
can_3->SetFrameBorderMode(0);
can_3->SetBottomMargin(0.3);
can_3->SetBorderMode(0);
data_site3->Draw();
hs_site3->Draw("same");
data_site3->SetTitle("");
// data_site3->Draw("same");
// pred_site3->Draw("same");
data_site3->GetXaxis()->SetTitle("Reconstructed Energy [MeV]");
data_site3->GetXaxis()->SetTitleSize(0.09);
data_site3->GetXaxis()->SetTitleOffset(1.45);
data_site3->GetXaxis()->SetLabelSize(0.09);
data_site3->GetXaxis()->Draw();
data_site3->GetYaxis()->SetNdivisions(508);
data_site3->GetYaxis()->SetLabelSize(0.08);
data_site3->GetYaxis()->SetTitleSize(0.08);
data_site3->GetYaxis()->SetTitleOffset(0.6);
data_site3->GetYaxis()->CenterTitle(true);
can_3->RedrawAxis();
TLegend leg3(0.65,0.85-0.20,0.85,0.85);
leg3.AddEntry(data_site3, " EH3", "lp");
leg3.AddEntry(acc_site3, " Acc. Bkgd", "f");
leg3.SetFillColor(kWhite);
leg3.Draw();
can_3->Modified();
c1.cd();
TString name("SpectraSite");
// print 3 figures by default
c1.SaveAs(name + ".eps");
c1.SaveAs(name + ".pdf");
c1.SaveAs(name + ".png");
TString extra(type);
if (! (extra == "eps" || extra == "pdf" || extra == "png")) {
c1.SaveAs(name + "." + type);
}
}
int main(int argc, char *argv[])
{
ArgMapping amap;
long m=17;
amap.arg("m", m, "cyclotomic index");
amap.note("e.g., m=2047");
long p=2;
amap.arg("p", p, "plaintext base");
long r=1;
amap.arg("r", r, "lifting");
Vec<long> gens0;
amap.arg("gens", gens0, "use specified vector of generators", NULL);
amap.note("e.g., gens='[562 1871 751]'");
Vec<long> ords0;
amap.arg("ords", ords0, "use specified vector of orders", NULL);
amap.note("e.g., ords='[4 2 -4]', negative means 'bad'");
amap.parse(argc, argv);
cout << "m = " << m << ", p = " << p << ", r = " << r << endl;
vector<long> f;
factorize(f,m);
cout << "factoring "<<m<<" gives [";
for (unsigned long i=0; i<f.size(); i++)
cout << f[i] << " ";
cout << "]\n";
vector<long> gens1, ords1;
convert(gens1, gens0);
convert(ords1, ords0);
PAlgebra al(m, p, gens1, ords1);
al.printout();
cout << "\n";
PAlgebraMod almod(al, r);
FHEcontext context(m, p, r);
buildModChain(context, 5, 2);
stringstream s1;
writeContextBase(s1, context);
s1 << context;
string s2 = s1.str();
cout << s2 << endl;
stringstream s3(s2);
unsigned long m1, p1, r1;
vector<long> gens, ords;
readContextBase(s3, m1, p1, r1, gens, ords);
FHEcontext c1(m1, p1, r1, gens, ords);
s3 >> c1;
if (context == c1)
cout << "equal\n";
else
cout << "not equal\n";
return 0;
}
void CBoxProxyView::functionTest()
{
Wm5::Vector3d c1(0,0,0);
Wm5::Vector3d c2(4,4,0);
Wm5::Vector3d c3(3,1,0);
Wm5::Vector3d x1(1,0,0);
Wm5::Vector3d y1(0,1,0);
Wm5::Vector3d z1(0,0,1);
Wm5::Vector3d x2(1,1,0);
Wm5::Vector3d y2(-1,1,0);
Wm5::Vector3d z2(0,0,1);
Wm5::Box3d b(c1,x1,y1,z1,1,1,1);
Wm5::Box3d c(c2,x2,y2,z2,1,1,1);
Wm5::Box3d d(c3,x1,y1,z1,1,1,1);
testBoxA=new Box(b);
testBoxB=new Box(c);
testBoxC=new Box(d);
//*testBoxA=boxes.at(2);
for (int i=1;i<boxes.size();i++)
{
cI.alignBox(boxes.at(i),downDir);
}
for (int i=1;i<boxes.size()-1;i++)
{
for (int j=i+1;j<boxes.size();j++)
{
cI.alignBoxes(boxes.at(i),boxes.at(j));
}
}
for (int i=0;i<boxes.size()-1;i++)
{
for (int j=i+1;j<boxes.size();j++)
{
cI.removePenetrate(boxes.at(i),boxes.at(j));
}
}
Wm5::Box3d FBox=boxes.at(0).GetWmBox();
for (int i = 0; i < 6; i++)
{
Wm5::Vector3d Normal=cI.getNormal(FBox,i);
if (fabs(Normal.Dot(downDir))<0.95)
{
cI.extendWmBox(FBox,1,i);
}
}
boxes.at(0)=Box(FBox);
boxes.at(0).type=1;
extendedBoxes=boxes;
//cI.getTouch(testConSet,boxes.at(4),boxes.at(6),boxes.at(4).GetWmBox(),boxes.at(6).GetWmBox());
//cI.getContact(testConSet,boxes.at(4),boxes.at(6),boxes.at(4).GetWmBox(),boxes.at(6).GetWmBox());
//cI.removePenetrate(boxes.at(4),boxes.at(6));
//cI.alignBox(boxes.at(2),Axis);
//cI.alignBox(boxes.at(1),boxes.at(0).GetWmBox().Axis[1]);
//cI.getContactCandidateEx(testConSet,boxes.at(1),boxes.at(4));
//cI.getContactCandidateEx(testConSet,*testBoxA,*testBoxB);
//cI.getContactCandidateEx(testConSet2,*testBoxA,*testBoxC);
//cI.updateBox(b,testConSet.at(0),1);
//cI.updateBox(b,testConSet2.at(0),1);
//delete testBoxA;
//testBoxA=new Box(b);
vector<Box> testBoxes;
//testBoxes.push_back(*testBoxA);
//testBoxes.push_back(*testBoxB);
//testBoxes.push_back(*testBoxC);
//testBoxes.push_back(boxes.at(0));
//testBoxes.push_back(boxes.at(6));
//testBoxes.push_back(boxes.at(7));
//boxes=testBoxes;
//conGraph=new ContactGraph(boxes,Wm5::Vector3d::ZERO,0);
//while(conGraph->IterateOneStep());
//GraphCreated=true;
//Box bc=boxes.at(2);
}
void TeMANAGER::TeGDLegend::draw(std::vector<TeLegendEntryVector>& legends,
std::vector<std::string>& legendTitles,
const int& width)
{
// verifica quantas linhas tera a legenda: uma para cada legenda e mais uma para cada agrupamento
int legendVecSize = 0;
for(unsigned int i = 0; i < legends.size(); ++i)
{
if(legends[i].size() > 1) // se existe mais de uma legenda, entao temos um agrupamento!
legendVecSize += legends[i].size() + 1;
else // caso contrario, temos somente uma legenda
++legendVecSize;
}
if(legendVecSize == 0)
return;
// determina as dimensoes do canvas
int legendHeight = legendVecSize * 20;
double nlin = (double)legendHeight / 20.0;
double ncol = (double)width/20.0;
TeCoord2D c1(0.0, 0.0);
TeCoord2D c2(ncol, nlin);
TeBox b(0.0, 0.0, ncol, nlin);
// ajusta o canvas
gdCanvas_->setWorld(b, width, legendHeight);
// marca a posicao inicial de escrita
int currentLinePosition = 0;
double posd = legendVecSize - 1;
TeCoord2D c(ncol/2.0, posd + 0.60);
// desenha as legendas
for(unsigned int i = 0; i < legends.size(); ++i)
{
for(unsigned int j = 0; j < legends[i].size(); ++j)
{
posd = legendVecSize - 1 - currentLinePosition;
if((j == 0) && legends[i].size() > 1)
{
TeCoord2D c(0.2, posd + 0.60);
gdCanvas_->draw(c, legendTitles[i], 0.0, 0.5, 0.0);
++currentLinePosition;
posd = legendVecSize - 1 - currentLinePosition;
}
bool hasPOLYGONS = (legends[i][j].getVisualMap().find(TePOLYGONS) != legends[i][j].getVisualMap().end());
bool hasLINES = (legends[i][j].getVisualMap().find(TeLINES) != legends[i][j].getVisualMap().end());
bool hasPOINTS = (legends[i][j].getVisualMap().find(TePOINTS) != legends[i][j].getVisualMap().end());
double dx = 0;
if(hasPOLYGONS)
dx = 1.75;
if(hasLINES)
dx += 1.75;
if(hasPOINTS)
dx += 1.75;
if((j == 0) && legends[i].size() == 1)
{
TeCoord2D c(dx, posd + 0.60);
gdCanvas_->draw(c, legendTitles[i], 0.0, 0.5, 0.0);
}
else
{
TeCoord2D c(dx, posd + 0.60);
gdCanvas_->draw(c, legends[i][j].label(), 0.0, 0.5, 0.0);
}
if(hasPOLYGONS)
{
TeCoord2D c1, c2, c3, c4;
c1.setXY(0.2, posd + 0.15);
c2.setXY(0.2, posd + 0.9);
c3.setXY(1.5, posd + 0.9);
c4.setXY(1.5, posd + 0.15);
TeLine2D l;
l.add(c1); l.add(c2); l.add(c3); l.add(c4); l.add(c1);
TeLinearRing r(l);
TePolygon p;
p.add(r);
// Draw the legend polygon
TeGeomRepVisualMap& visualMap = legends[i][j].getVisualMap();
TeVisual& polygonVisual = *(visualMap[TePOLYGONS]);
TeColor& polygonColor = polygonVisual.color();
TeColor& polygonContourColor = polygonVisual.contourColor();
gdCanvas_->setPolygonColor(polygonColor.red_, polygonColor.green_, polygonColor.blue_, polygonVisual.transparency());
gdCanvas_->setPolygonStyle(polygonVisual.style());
gdCanvas_->setPolygonLineColor(polygonContourColor.red_, polygonContourColor.green_, polygonContourColor.blue_);
gdCanvas_->setPolygonLineStyle(polygonVisual.contourStyle(), polygonVisual.contourWidth());
gdCanvas_->draw(p);
}
if(hasLINES)
{
dx = 0;
if(hasPOLYGONS)
dx = 1.75;
TeCoord2D c1, c2, c3, c4;
c1.setXY(0.2 + dx, posd + 0.15);
c2.setXY(0.6 + dx, posd + 0.9);
c3.setXY(1.0 + dx, posd + 0.15);
c4.setXY(1.5 + dx, posd + 0.9);
TeLine2D l;
l.add(c1); l.add(c2); l.add(c3); l.add(c4);
TeGeomRepVisualMap& visualMap = legends[i][j].getVisualMap();
TeVisual& lnVisual = *(visualMap[TeLINES]);
TeColor& lnColor = lnVisual.color();
gdCanvas_->setLineColor(lnColor.red_, lnColor.green_, lnColor.blue_);
gdCanvas_->setLineStyle(lnVisual.style(), lnVisual.width() + 1);
gdCanvas_->draw(l);
}
if(hasPOINTS)
{
dx = 0;
if(hasPOLYGONS)
dx = 1.75;
if(hasLINES)
dx += 1.75;
TeCoord2D c(0.6 + dx, posd + 0.6);
TePoint pt(c);
TeGeomRepVisualMap& visualMap = legends[i][j].getVisualMap();
TeVisual& ptVisual = *(visualMap[TePOINTS]);
TeColor& ptColor = ptVisual.color();
gdCanvas_->setPointColor(ptColor.red_, ptColor.green_, ptColor.blue_);
gdCanvas_->setPointStyle(ptVisual.style(), ptVisual.size() + 1);
gdCanvas_->draw(pt);
}
++currentLinePosition;
}
}
}
/** return cloned graphic path with coordinates modified with crispEdges algorithm
@remarks
depending on fCreateStorageForCrispEdges status & on VGraphicContext crispEdges status
return NULL if crispEdges is disabled
*/
VGraphicPath *VGraphicPath::CloneWithCrispEdges( VGraphicContext *inGC, bool inFillOnly) const
{
if (inGC == NULL || !inGC->IsShapeCrispEdgesEnabled() || !inGC->IsAllowedCrispEdgesOnPath() || !fCreateStorageForCrispEdges || fDrawCmds.empty())
return NULL;
if (fHasBezier && !inGC->IsAllowedCrispEdgesOnBezier())
return NULL;
VGraphicPath *path = inGC->CreatePath();
if (!path)
return NULL;
path->fCreateStorageForCrispEdges = false;
path->Begin();
VGraphicPathDrawCmds::const_iterator it = fDrawCmds.begin();
bool isIdentity = fCurTransform.IsIdentity();
VAffineTransform ctm;
if (!isIdentity)
{
inGC->GetTransform( ctm);
inGC->SetTransform( fCurTransform * ctm);
}
for (;it != fDrawCmds.end(); it++)
{
switch (it->GetType())
{
case GPDCT_BEGIN_SUBPATH_AT:
{
VPoint pt(*(it->GetPoints()));
inGC->_CEAdjustPointInTransformedSpace( pt, inFillOnly);
path->BeginSubPathAt( pt);
}
break;
case GPDCT_ADD_LINE_TO:
{
VPoint pt(*(it->GetPoints()));
inGC->_CEAdjustPointInTransformedSpace( pt, inFillOnly);
path->AddLineTo( pt);
}
break;
case GPDCT_ADD_BEZIER_TO:
{
VPoint c1(*(it->GetPoints()));
VPoint d(*(it->GetPoints()+1));
VPoint c2(*(it->GetPoints()+2));
inGC->_CEAdjustPointInTransformedSpace( c1, inFillOnly);
inGC->_CEAdjustPointInTransformedSpace( d, inFillOnly);
inGC->_CEAdjustPointInTransformedSpace( c2, inFillOnly);
path->AddBezierTo( c1, d, c2);
}
break;
case GPDCT_CLOSE_SUBPATH:
path->CloseSubPath();
break;
case GPDCT_ADD_OVAL:
{
VRect rect(it->GetRect());
inGC->_CEAdjustRectInTransformedSpace( rect, inFillOnly);
path->AddOval( rect);
}
break;
case GPDCT_SET_POS_BY:
path->SetPosBy( it->GetPoints()->GetX(), it->GetPoints()->GetY());
break;
case GPDCT_SET_SIZE_BY:
path->SetSizeBy( it->GetPoints()->GetX(), it->GetPoints()->GetY());
break;
default:
xbox_assert(false);
break;
}
}
if (!isIdentity)
inGC->SetTransform( ctm);
path->End();
return path;
}
void SkpThemedBase::skp_draw_themed()
{
// QPainterPath path;
// path.setFillRule(Qt::WindingFill);
// path.addRect(10, 10, m_parent->width()-20, m_parent->height()-20);
// QPainter painter(m_parent);
// painter.setRenderHint(QPainter::Antialiasing, true);
// painter.fillPath(path, QBrush(Qt::white));
// QColor color(0, 0, 0, 50);
// for(int i=0; i<10; i++)
// {
// QPainterPath path;
// path.setFillRule(Qt::WindingFill);
// path.addRect(10-i, 10-i, m_parent->width()-(10-i)*2, m_parent->height()-(10-i)*2);
// color.setAlpha(150 - qSqrt(i)*50);
// painter.setPen(color);
// painter.drawPath(path);
// }
/*
QPainter p(m_parent);
QPen pen(QColor(255, 255, 255, 255));
pen.setWidth(2);
pen.setStyle(Qt::NoPen);
p.setPen(pen);
QPainterPath path;
QPoint bottomRight = m_parent->rect().bottomRight();
QRect pathRect = m_parent->rect();
pathRect.setBottomRight(QPoint(bottomRight.x()-1, bottomRight.y()-1));
path.addRoundedRect(pathRect, 0, 0);
QString themeType = MOption::instance()->option("WindowBGPixmapType", "theme").toString();
if(themeType == "bitmap") {
if(!m_cachedPixmap.isNull()) {
p.fillPath(path, QBrush(m_cachedPixmap));
} else {
QColor color(100,178,226,255);
MOption::instance()->setOption(QVariant(color), "WindowBGColor", "theme");
MOption::instance()->setOption("color", "WindowBGPixmapType", "theme");
MOption::instance()->setOption(QVariant(color), OPTION_AVERAGE_COLOR, OPTION_GROUP_Theme);
p.fillPath(path, color);
}
} else if(themeType == "color") {
QImage image(QSize(100, 100), QImage::Format_ARGB32);
image.fill(MOption::instance()->option("WindowBGColor", "theme").value<QColor>());
m_cachedPixmap = setAlphaPixmap(QPixmap::fromImage(image), m_aeroTransparent);
p.fillPath(path, QBrush(m_cachedPixmap));
}
QRect linearRect(0, m_titleHeight, m_parent->width(), m_linearHeight);
QLinearGradient linear(0, m_titleHeight, 0, m_linearHeight+m_titleHeight);
QColor c1(255, 255, 255, m_widgetTransparent /2);;
QColor c2(255, 255, 255, m_widgetTransparent);
linear.setColorAt(0.0, QColor(255, 255, 255, 255));
linear.setColorAt(0.5, c1);
linear.setColorAt(1.0, c2);
p.setBrush(QBrush(linear));
p.fillRect(linearRect, QBrush(linear));
QPainterPath clientPath;
QRect clientRect(0, m_titleHeight + m_linearHeight,
m_parent->width(), m_parent->height() - m_titleHeight - m_linearHeight - m_statusHeight);
clientPath.addRect(clientRect);
p.fillPath(clientPath, QBrush(QColor(255, 255, 255, m_widgetTransparent)));
p.strokePath(path, QPen(QColor(0, 0, 0, 150)));
*/
QPainter p(m_parent);
int width = 5;
QColor color(0, 0, 0, 20);
for(int i=0; i<width; i++)
{
QPainterPath path;
path.setFillRule(Qt::WindingFill);
path.addRect(width-i, width-i, m_parent->width()-(width-i)*2, m_parent->height()-(width-i)*2);
color.setAlpha(60 - qSqrt(i)*30);
p.setPen(color);
p.drawPath(path);
}
QRect pathRect(width, width, m_parent->rect().width() - width * 2, m_parent->rect().height() - width * 2);
QPainterPath path;
path.addRoundedRect(pathRect, 0, 0);
QString themeType = MOption::instance()->option("WindowBGPixmapType", "theme").toString();
if(themeType == "bitmap") {
if(!m_cachedPixmap.isNull()) {
p.fillPath(path, QBrush(m_cachedPixmap));
} else {
QColor color(100,178,226,255);
MOption::instance()->setOption(QVariant(color), "WindowBGColor", "theme");
MOption::instance()->setOption("color", "WindowBGPixmapType", "theme");
MOption::instance()->setOption(QVariant(color), OPTION_AVERAGE_COLOR, OPTION_GROUP_Theme);
p.fillPath(path, color);
}
} else if(themeType == "color") {
QImage image(QSize(100, 100), QImage::Format_ARGB32);
image.fill(MOption::instance()->option("WindowBGColor", "theme").value<QColor>());
m_cachedPixmap = setAlphaPixmap(QPixmap::fromImage(image), m_aeroTransparent);
p.fillPath(path, QBrush(m_cachedPixmap));
}
QRect linearRect(0, m_titleHeight, m_parent->width(), m_linearHeight);
QLinearGradient linear(0, m_titleHeight, 0, m_linearHeight+m_titleHeight);
QColor c1(255, 255, 255, m_widgetTransparent /2);;
QColor c2(255, 255, 255, m_widgetTransparent);
linear.setColorAt(0.0, QColor(255, 255, 255, 255));
linear.setColorAt(0.5, c1);
linear.setColorAt(1.0, c2);
p.setBrush(QBrush(linear));
p.fillRect(linearRect, QBrush(linear));
QPainterPath clientPath;
QRect clientRect(width, m_titleHeight + m_linearHeight,
m_parent->width() - width * 2, m_parent->height() - m_titleHeight - m_linearHeight - m_statusHeight - width * 2);
clientPath.addRect(clientRect);
p.fillPath(clientPath, QBrush(QColor(255, 255, 255, m_widgetTransparent)));
}
/************** Each round consists of the following:
1. c1.multiplyBy(c0)
2. c0 += random constant
3. c2 *= random constant
4. tmp = c1
5. ea.rotate(tmp, random amount in [-nSlots/2, nSlots/2])
6. c2 += tmp
7. ea.rotate(c2, random amount in [1-nSlots, nSlots-1])
8. c1.negate()
9. c3.multiplyBy(c2)
10. c0 -= c3
**************/
void testGeneralOps(const FHEPubKey& publicKey, const FHESecKey& secretKey,
const EncryptedArrayCx& ea, double epsilon,
long nRounds)
{
long nslots = ea.size();
char buffer[32];
vector<cx_double> p0, p1, p2, p3;
ea.random(p0);
ea.random(p1);
ea.random(p2);
ea.random(p3);
Ctxt c0(publicKey), c1(publicKey), c2(publicKey), c3(publicKey);
ea.encrypt(c0, publicKey, p0, /*size=*/1.0);
ea.encrypt(c1, publicKey, p1, /*size=*/1.0);
ea.encrypt(c2, publicKey, p2, /*size=*/1.0);
ea.encrypt(c3, publicKey, p3, /*size=*/1.0);
resetAllTimers();
FHE_NTIMER_START(Circuit);
for (long i = 0; i < nRounds; i++) {
if (verbose) std::cout << "*** round " << i << "..."<<endl;
long shamt = RandomBnd(2*(nslots/2) + 1) - (nslots/2);
// random number in [-nslots/2..nslots/2]
long rotamt = RandomBnd(2*nslots - 1) - (nslots - 1);
// random number in [-(nslots-1)..nslots-1]
// two random constants
vector<cx_double> const1, const2;
ea.random(const1);
ea.random(const2);
ZZX const1_poly, const2_poly;
ea.encode(const1_poly, const1, /*size=*/1.0);
ea.encode(const2_poly, const2, /*size=*/1.0);
mul(p1, p0); // c1.multiplyBy(c0)
c1.multiplyBy(c0);
if (verbose) {
CheckCtxt(c1, "c1*=c0");
debugCompare(ea, secretKey, p1, c1, epsilon);
}
add(p0, const1); // c0 += random constant
c0.addConstant(const1_poly);
if (verbose) {
CheckCtxt(c0, "c0+=k1");
debugCompare(ea, secretKey, p0, c0, epsilon);
}
mul(p2, const2); // c2 *= random constant
c2.multByConstant(const2_poly);
if (verbose) {
CheckCtxt(c2, "c2*=k2");
debugCompare(ea, secretKey, p2, c2, epsilon);
}
vector<cx_double> tmp_p(p1); // tmp = c1
Ctxt tmp(c1);
sprintf(buffer, "tmp=c1>>=%d", (int)shamt);
rotate(tmp_p, shamt); // ea.shift(tmp, random amount in [-nSlots/2,nSlots/2])
ea.rotate(tmp, shamt);
if (verbose) {
CheckCtxt(tmp, buffer);
debugCompare(ea, secretKey, tmp_p, tmp, epsilon);
}
add(p2, tmp_p); // c2 += tmp
c2 += tmp;
if (verbose) {
CheckCtxt(c2, "c2+=tmp");
debugCompare(ea, secretKey, p2, c2, epsilon);
}
sprintf(buffer, "c2>>>=%d", (int)rotamt);
rotate(p2, rotamt); // ea.rotate(c2, random amount in [1-nSlots, nSlots-1])
ea.rotate(c2, rotamt);
if (verbose) {
CheckCtxt(c2, buffer);
debugCompare(ea, secretKey, p2, c2, epsilon);
}
negateVec(p1); // c1.negate()
c1.negate();
if (verbose) {
CheckCtxt(c1, "c1=-c1");
debugCompare(ea, secretKey, p1, c1, epsilon);
}
mul(p3, p2); // c3.multiplyBy(c2)
c3.multiplyBy(c2);
if (verbose) {
CheckCtxt(c3, "c3*=c2");
debugCompare(ea, secretKey, p3, c3, epsilon);
}
sub(p0, p3); // c0 -= c3
c0 -= c3;
if (verbose) {
CheckCtxt(c0, "c0=-c3");
debugCompare(ea, secretKey, p0, c0, epsilon);
}
}
c0.cleanUp();
c1.cleanUp();
c2.cleanUp();
c3.cleanUp();
FHE_NTIMER_STOP(Circuit);
vector<cx_double> pp0, pp1, pp2, pp3;
ea.decrypt(c0, secretKey, pp0);
ea.decrypt(c1, secretKey, pp1);
ea.decrypt(c2, secretKey, pp2);
ea.decrypt(c3, secretKey, pp3);
std::cout << "Test "<<nRounds<<" rounds of mixed operations, ";
if (cx_equals(pp0, p0,conv<double>(epsilon*c0.getPtxtMag()))
&& cx_equals(pp1, p1,conv<double>(epsilon*c1.getPtxtMag()))
&& cx_equals(pp2, p2,conv<double>(epsilon*c2.getPtxtMag()))
&& cx_equals(pp3, p3,conv<double>(epsilon*c3.getPtxtMag())))
std::cout << "PASS\n\n";
else {
std::cout << "FAIL:\n";
std::cout << " max(p0)="<<largestCoeff(p0)
<< ", max(pp0)="<<largestCoeff(pp0)
<< ", maxDiff="<<calcMaxDiff(p0,pp0) << endl;
std::cout << " max(p1)="<<largestCoeff(p1)
<< ", max(pp1)="<<largestCoeff(pp1)
<< ", maxDiff="<<calcMaxDiff(p1,pp1) << endl;
std::cout << " max(p2)="<<largestCoeff(p2)
<< ", max(pp2)="<<largestCoeff(pp2)
<< ", maxDiff="<<calcMaxDiff(p2,pp2) << endl;
std::cout << " max(p3)="<<largestCoeff(p3)
<< ", max(pp3)="<<largestCoeff(pp3)
<< ", maxDiff="<<calcMaxDiff(p3,pp3) << endl<<endl;
}
if (verbose) {
std::cout << endl;
printAllTimers();
std::cout << endl;
}
resetAllTimers();
}
int main()
{
// test if two ints are equal or not
cout << "*** Integers Tests ***" << endl;
int leftInts[4] = { 1, 2, -1, -1 }; // lhs integers used for testing equality
int rightInts[4] = { 1, 4, 1, -1 }; // rhs integers used for testing equality
for (int a = 0; a < 4; a++)
{
cout << "Integers: " << leftInts[a] << " and " << rightInts[a] << " are "
<< (isEqualTo(leftInts[a], rightInts[a]) ? "equal" : "\"NOT\" equal") << '\n';
}
// test if two chars are equal or not
cout << "\n\n*** Chars Tests ***" << endl;
char leftChars[4] = { 'a', 'a', 'c', 'c' }; // lhs chars used for testing equality
char rightChars[4] = { 'a', 'c', 'a', 'c' }; // rhs chars used for testing equality
for (int a = 0; a < 4; a++)
{
cout << "Characters: " << leftChars[a] << " and " << rightChars[a] << " are "
<< (isEqualTo(leftChars[a], rightChars[a]) ? "equal" : "\"NOT\" equal") << '\n';
}
// test if two doubles are equal or not
cout << "\n\n*** Double Tests ***" << endl;
double leftDoubles[4] = { 2.2, 2.2, -2.2, -2.2 }; // lhs integers used for testing equality
double rightDoubles[4] = { 2.2, 2.3, 2.2, -2.2 }; // rhs integers used for testing equality
for (int a = 0; a < 4; a++)
{
cout << "Double numbers: " << leftDoubles[a] << " and " << rightDoubles[a] << " are "
<< (isEqualTo(leftDoubles[a], rightDoubles[a]) ? "equal" : "\"NOT\" equal") << '\n';
}
// test if two Complex objects are equal
cout << "\n\n*** Complex Tests ***" << endl;
Complex a(10, 5); // Complex objects used
Complex a1(10, 5); // for testing equality
cout << "Class objects: " << a << " and " << a1 << " are "
<< (isEqualTo(a, a1) ? "equal" : "\"NOT\" equal");
Complex b(10, 5); // Complex objects used
Complex b1(10, 54); // for testing equality
cout << "\nClass objects: " << b << " and " << b1 << " are "
<< (isEqualTo(b, b1) ? "equal" : "\"NOT\" equal");
Complex c(10, -5); // Complex objects used
Complex c1(10, 5); // for testing equality
cout << "\nClass objects: " << c << " and " << c1 << " are "
<< (isEqualTo(c, c1) ? "equal" : "\"NOT\" equal");
Complex d(-10, -5); // Complex objects used
Complex d1(-10, -5); // for testing equality
cout << "\nClass objects: " << d << " and " << d1 << " are "
<< (isEqualTo(d, d1) ? "equal" : "\"NOT\" equal");
//test if two strings are equal or not
cout << "\n\n\n*** String Tests ***" << endl;
string leftStrings[4] = { "abcdefg", "abcdefg", "-abcdefg", "-abcdefg" }; // lhs chars used for testing equality
string rightStrings[4] = { "abcdefg", "abcdefh", "abcdefg", "-abcdefg" }; // rhs chars used for testing equality
for (int a = 0; a < 4; a++)
{
cout << "String objects: " << leftStrings[a] << " and " << rightStrings[a] << " are "
<< (isEqualTo(leftStrings[a], rightStrings[a]) ? "equal" : "\"NOT\" equal") << '\n';
}
//test if two dates are equal or not
cout << "\n\n*** Date Tests ***";
Date dayA(2, 31, 2016); // create date object
Date dayB(2, 31, 2016); // create date object
cout << "\nDate objects: " << dayA << " and " << dayB << " are "
<< (isEqualTo(dayA, dayB) ? "equal" : "\"NOT\" equal");
Date dayC(-2, 13, 2016); // create date object
Date dayD(2, 14, 2016); // create date object
cout << "\nDate objects: " << dayC << " and " << dayD << " are "
<< (isEqualTo(dayC, dayD) ? "equal" : "\"NOT\" equal");
Date dayE(-2, 13, 2016); // create date object
Date dayF(2, 13, 2016); // create date object
cout << "\nDate objects: " << dayE << " and " << dayF << " are "
<< (isEqualTo(dayE, dayF) ? "equal" : "\"NOT\" equal");
Date dayG(-2, 13, 2016); // create date object
Date dayH(2, 31, 2016); // create date object
cout << "\nDate objects: " << dayG << " and " << dayH << " are "
<< (isEqualTo(dayG, dayH) ? "equal" : "\"NOT\" equal") << '\n';
cout << endl << endl;
return 0;
} // end main
void testBasicArith(const FHEPubKey& publicKey,
const FHESecKey& secretKey,
const EncryptedArrayCx& ea, double epsilon)
{
if (verbose) cout << "Test Arithmetic ";
// Test objects
Ctxt c1(publicKey), c2(publicKey), c3(publicKey);
vector<cx_double> vd;
vector<cx_double> vd1, vd2, vd3;
ea.random(vd1);
ea.random(vd2);
// test encoding of shorter vectors
vd1.resize(vd1.size()-2);
ea.encrypt(c1, publicKey, vd1, /*size=*/1.0);
vd1.resize(vd1.size()+2, 0.0);
ea.encrypt(c2, publicKey, vd2, /*size=*/1.0);
// Test - Multiplication
c1 *= c2;
for (long i=0; i<lsize(vd1); i++) vd1[i] *= vd2[i];
ZZX poly;
ea.random(vd3);
ea.encode(poly, vd3, /*size=*/1.0);
c1.addConstant(poly); // vd1*vd2 + vd3
for (long i=0; i<lsize(vd1); i++) vd1[i] += vd3[i];
// Test encoding, encryption of a single number
double xx = NTL::RandomLen_long(16)/double(1L<<16); // random in [0,1]
ea.encryptOneNum(c2, publicKey, xx);
c1 += c2;
for (auto& x : vd1) x += xx;
// Test - Multiply by a mask
vector<long> mask(lsize(vd1), 1);
for (long i=0; i*(i+1)<lsize(mask); i++) {
mask[i*i] = 0;
mask[i*(i+1)] = -1;
}
ea.encode(poly,mask, /*size=*/1.0);
c1.multByConstant(poly); // mask*(vd1*vd2 + vd3)
for (long i=0; i<lsize(vd1); i++) vd1[i] *= mask[i];
// Test - Addition
ea.random(vd3);
ea.encrypt(c3, publicKey, vd3, /*size=*/1.0);
c1 += c3;
for (long i=0; i<lsize(vd1); i++) vd1[i] += vd3[i];
c1.negate();
c1.addConstant(to_ZZ(1));
for (long i=0; i<lsize(vd1); i++) vd1[i] = 1.0 - vd1[i];
// Diff between approxNums HE scheme and plaintext floating
ea.decrypt(c1, secretKey, vd);
#ifdef DEBUG_PRINTOUT
printVec(cout<<"res=", vd, 10)<<endl;
printVec(cout<<"vec=", vd1, 10)<<endl;
#endif
if (verbose)
cout << "(max |res-vec|_{infty}="<< calcMaxDiff(vd, vd1) << "): ";
if (cx_equals(vd, vd1, conv<double>(epsilon*c1.getPtxtMag())))
cout << "GOOD\n";
else {
cout << "BAD:\n";
std::cout << " max(vd)="<<largestCoeff(vd)
<< ", max(vd1)="<<largestCoeff(vd1)
<< ", maxDiff="<<calcMaxDiff(vd,vd1) << endl<<endl;
}
}
void operator()(MESH& m, double t) {
c1(m,t);
c2(m,t);
}
void testComplexArith(const FHEPubKey& publicKey,
const FHESecKey& secretKey,
const EncryptedArrayCx& ea, double epsilon)
{
// Test complex conjugate
Ctxt c1(publicKey), c2(publicKey);
vector<cx_double> vd;
vector<cx_double> vd1, vd2;
ea.random(vd1);
ea.random(vd2);
ea.encrypt(c1, publicKey, vd1, /*size=*/1.0);
ea.encrypt(c2, publicKey, vd2, /*size=*/1.0);
if (verbose)
cout << "Test Conjugate: ";
for_each(vd1.begin(), vd1.end(), [](cx_double& d){d=std::conj(d);});
c1.complexConj();
ea.decrypt(c1, secretKey, vd);
#ifdef DEBUG_PRINTOUT
printVec(cout<<"vd1=", vd1, 10)<<endl;
printVec(cout<<"res=", vd, 10)<<endl;
#endif
if (cx_equals(vd, vd1, conv<double>(epsilon*c1.getPtxtMag())))
cout << "GOOD\n";
else {
cout << "BAD:\n";
std::cout << " max(vd)="<<largestCoeff(vd)
<< ", max(vd1)="<<largestCoeff(vd1)
<< ", maxDiff="<<calcMaxDiff(vd,vd1) << endl<<endl;
}
// Test that real and imaginary parts are actually extracted.
Ctxt realCtxt(c2), imCtxt(c2);
vector<cx_double> realParts(vd2), real_dec;
vector<cx_double> imParts(vd2), im_dec;
if (verbose)
cout << "Test Real and Im parts: ";
for_each(realParts.begin(), realParts.end(), [](cx_double& d){d=std::real(d);});
for_each(imParts.begin(), imParts.end(), [](cx_double& d){d=std::imag(d);});
ea.extractRealPart(realCtxt);
ea.decrypt(realCtxt, secretKey, real_dec);
ea.extractImPart(imCtxt);
ea.decrypt(imCtxt, secretKey, im_dec);
#ifdef DEBUG_PRINTOUT
printVec(cout<<"vd2=", vd2, 10)<<endl;
printVec(cout<<"real=", realParts, 10)<<endl;
printVec(cout<<"res=", real_dec, 10)<<endl;
printVec(cout<<"im=", imParts, 10)<<endl;
printVec(cout<<"res=", im_dec, 10)<<endl;
#endif
if (cx_equals(realParts,real_dec,conv<double>(epsilon*realCtxt.getPtxtMag()))
&& cx_equals(imParts, im_dec, conv<double>(epsilon*imCtxt.getPtxtMag())))
cout << "GOOD\n";
else {
cout << "BAD:\n";
std::cout << " max(re)="<<largestCoeff(realParts)
<< ", max(re1)="<<largestCoeff(real_dec)
<< ", maxDiff="<<calcMaxDiff(realParts,real_dec) << endl;
std::cout << " max(im)="<<largestCoeff(imParts)
<< ", max(im1)="<<largestCoeff(im_dec)
<< ", maxDiff="<<calcMaxDiff(imParts,im_dec) << endl<<endl;
}
}
int main()
{
{
int a1[] = {1, 3, 7, 9, 10};
int a2[] = {0, 2, 4, 5, 6, 8, 11};
std::vector<int> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
std::vector<int> c2(a2, a2+sizeof(a2)/sizeof(a2[0]));
assert(is_contiguous_container_asan_correct(c1));
assert(is_contiguous_container_asan_correct(c2));
swap(c1, c2);
assert(c1 == std::vector<int>(a2, a2+sizeof(a2)/sizeof(a2[0])));
assert(c2 == std::vector<int>(a1, a1+sizeof(a1)/sizeof(a1[0])));
assert(is_contiguous_container_asan_correct(c1));
assert(is_contiguous_container_asan_correct(c2));
}
{
int a1[] = {1, 3, 7, 9, 10};
int a2[] = {0, 2, 4, 5, 6, 8, 11};
std::vector<int> c1(a1, a1);
std::vector<int> c2(a2, a2+sizeof(a2)/sizeof(a2[0]));
assert(is_contiguous_container_asan_correct(c1));
assert(is_contiguous_container_asan_correct(c2));
swap(c1, c2);
assert(c1 == std::vector<int>(a2, a2+sizeof(a2)/sizeof(a2[0])));
assert(c2.empty());
assert(distance(c2.begin(), c2.end()) == 0);
assert(is_contiguous_container_asan_correct(c1));
assert(is_contiguous_container_asan_correct(c2));
}
{
int a1[] = {1, 3, 7, 9, 10};
int a2[] = {0, 2, 4, 5, 6, 8, 11};
std::vector<int> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
std::vector<int> c2(a2, a2);
assert(is_contiguous_container_asan_correct(c1));
assert(is_contiguous_container_asan_correct(c2));
swap(c1, c2);
assert(c1.empty());
assert(distance(c1.begin(), c1.end()) == 0);
assert(c2 == std::vector<int>(a1, a1+sizeof(a1)/sizeof(a1[0])));
assert(is_contiguous_container_asan_correct(c1));
assert(is_contiguous_container_asan_correct(c2));
}
{
int a1[] = {1, 3, 7, 9, 10};
int a2[] = {0, 2, 4, 5, 6, 8, 11};
std::vector<int> c1(a1, a1);
std::vector<int> c2(a2, a2);
assert(is_contiguous_container_asan_correct(c1));
assert(is_contiguous_container_asan_correct(c2));
swap(c1, c2);
assert(c1.empty());
assert(distance(c1.begin(), c1.end()) == 0);
assert(c2.empty());
assert(distance(c2.begin(), c2.end()) == 0);
assert(is_contiguous_container_asan_correct(c1));
assert(is_contiguous_container_asan_correct(c2));
}
{
int a1[] = {1, 3, 7, 9, 10};
int a2[] = {0, 2, 4, 5, 6, 8, 11};
typedef test_allocator<int> A;
std::vector<int, A> c1(a1, a1+sizeof(a1)/sizeof(a1[0]), A(1, 1));
std::vector<int, A> c2(a2, a2+sizeof(a2)/sizeof(a2[0]), A(1, 2));
swap(c1, c2);
assert((c1 == std::vector<int, A>(a2, a2+sizeof(a2)/sizeof(a2[0]))));
assert(c1.get_allocator().get_id() == 1);
assert((c2 == std::vector<int, A>(a1, a1+sizeof(a1)/sizeof(a1[0]))));
assert(c2.get_allocator().get_id() == 2);
}
{
int a1[] = {1, 3, 7, 9, 10};
int a2[] = {0, 2, 4, 5, 6, 8, 11};
typedef other_allocator<int> A;
std::vector<int, A> c1(a1, a1+sizeof(a1)/sizeof(a1[0]), A(1));
std::vector<int, A> c2(a2, a2+sizeof(a2)/sizeof(a2[0]), A(2));
assert(is_contiguous_container_asan_correct(c1));
assert(is_contiguous_container_asan_correct(c2));
swap(c1, c2);
assert((c1 == std::vector<int, A>(a2, a2+sizeof(a2)/sizeof(a2[0]))));
assert(c1.get_allocator() == A(2));
assert((c2 == std::vector<int, A>(a1, a1+sizeof(a1)/sizeof(a1[0]))));
assert(c2.get_allocator() == A(1));
assert(is_contiguous_container_asan_correct(c1));
assert(is_contiguous_container_asan_correct(c2));
}
#if TEST_STD_VER >= 11
{
int a1[] = {1, 3, 7, 9, 10};
int a2[] = {0, 2, 4, 5, 6, 8, 11};
std::vector<int, min_allocator<int>> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
std::vector<int, min_allocator<int>> c2(a2, a2+sizeof(a2)/sizeof(a2[0]));
assert(is_contiguous_container_asan_correct(c1));
assert(is_contiguous_container_asan_correct(c2));
swap(c1, c2);
assert((c1 == std::vector<int, min_allocator<int>>(a2, a2+sizeof(a2)/sizeof(a2[0]))));
assert((c2 == std::vector<int, min_allocator<int>>(a1, a1+sizeof(a1)/sizeof(a1[0]))));
assert(is_contiguous_container_asan_correct(c1));
assert(is_contiguous_container_asan_correct(c2));
}
{
int a1[] = {1, 3, 7, 9, 10};
int a2[] = {0, 2, 4, 5, 6, 8, 11};
std::vector<int, min_allocator<int>> c1(a1, a1);
std::vector<int, min_allocator<int>> c2(a2, a2+sizeof(a2)/sizeof(a2[0]));
assert(is_contiguous_container_asan_correct(c1));
assert(is_contiguous_container_asan_correct(c2));
swap(c1, c2);
assert((c1 == std::vector<int, min_allocator<int>>(a2, a2+sizeof(a2)/sizeof(a2[0]))));
assert(c2.empty());
assert(distance(c2.begin(), c2.end()) == 0);
assert(is_contiguous_container_asan_correct(c1));
assert(is_contiguous_container_asan_correct(c2));
}
{
int a1[] = {1, 3, 7, 9, 10};
int a2[] = {0, 2, 4, 5, 6, 8, 11};
std::vector<int, min_allocator<int>> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
std::vector<int, min_allocator<int>> c2(a2, a2);
assert(is_contiguous_container_asan_correct(c1));
assert(is_contiguous_container_asan_correct(c2));
swap(c1, c2);
assert(c1.empty());
assert(distance(c1.begin(), c1.end()) == 0);
assert((c2 == std::vector<int, min_allocator<int>>(a1, a1+sizeof(a1)/sizeof(a1[0]))));
assert(is_contiguous_container_asan_correct(c1));
assert(is_contiguous_container_asan_correct(c2));
}
{
int a1[] = {1, 3, 7, 9, 10};
int a2[] = {0, 2, 4, 5, 6, 8, 11};
std::vector<int, min_allocator<int>> c1(a1, a1);
std::vector<int, min_allocator<int>> c2(a2, a2);
assert(is_contiguous_container_asan_correct(c1));
assert(is_contiguous_container_asan_correct(c2));
swap(c1, c2);
assert(c1.empty());
assert(distance(c1.begin(), c1.end()) == 0);
assert(c2.empty());
assert(distance(c2.begin(), c2.end()) == 0);
assert(is_contiguous_container_asan_correct(c1));
assert(is_contiguous_container_asan_correct(c2));
}
#ifndef _LIBCPP_DEBUG_LEVEL
// This test known to result in undefined behavior detected by _LIBCPP_DEBUG_LEVEL >= 1
{
int a1[] = {1, 3, 7, 9, 10};
int a2[] = {0, 2, 4, 5, 6, 8, 11};
typedef min_allocator<int> A;
std::vector<int, A> c1(a1, a1+sizeof(a1)/sizeof(a1[0]), A());
std::vector<int, A> c2(a2, a2+sizeof(a2)/sizeof(a2[0]), A());
assert(is_contiguous_container_asan_correct(c1));
assert(is_contiguous_container_asan_correct(c2));
swap(c1, c2);
assert((c1 == std::vector<int, A>(a2, a2+sizeof(a2)/sizeof(a2[0]))));
assert(c1.get_allocator() == A());
assert((c2 == std::vector<int, A>(a1, a1+sizeof(a1)/sizeof(a1[0]))));
assert(c2.get_allocator() == A());
assert(is_contiguous_container_asan_correct(c1));
assert(is_contiguous_container_asan_correct(c2));
}
#endif
#endif
}
void test01()
{
// class MyClass : YourClass
// {
// string message = "Hello";
// }
try
{
CIMName a = "A_class1";
CIMName b = "A_class2";
CIMClass c0(a, b);
CIMClass c1(a, CIMName("A_class2"));
CIMClass c2(CIMName("A_class1"), b);
CIMClass c3(b, a);
}
catch (InvalidNameException & ine)
{
if (verbose)
{
cout << "Caught unexpected exception: " << ine.getMessage() << endl;
}
}
try
{
//
// Invalid class name
//
CIMClass class0(CIMName ("//localhost/root/cimv2:MyClass"),
CIMName ("YourClass"));
PEGASUS_TEST_ASSERT(class0.getPath() ==
CIMObjectPath("//localhost/root/cimv2:MyClass"));
}
catch (InvalidNameException & ine)
{
if (verbose)
{
cout << "Caught expected exception: " << ine.getMessage() << endl;
}
}
CIMClass class1(CIMName ("MyClass"), CIMName ("YourClass"));
class1
.addQualifier(CIMQualifier(CIMName ("association"), true))
.addQualifier(CIMQualifier(CIMName ("q1"), Uint32(55)))
.addQualifier(CIMQualifier(CIMName ("q2"), String("Hello")))
.addProperty(CIMProperty(CIMName ("message"), String("Hello")))
.addProperty(CIMProperty(CIMName ("count"), Uint32(77), 0, CIMName(),
CIMName("YourClass"), true))
.addMethod(CIMMethod(CIMName ("isActive"), CIMTYPE_BOOLEAN)
.addParameter(CIMParameter(CIMName ("hostname"), CIMTYPE_STRING))
.addParameter(CIMParameter(CIMName ("port"), CIMTYPE_UINT32)));
// Test the method count function
PEGASUS_TEST_ASSERT(class1.getClassName().equal(CIMName ("myclass")));
PEGASUS_TEST_ASSERT(class1.getSuperClassName() == CIMName ("YourClass"));
PEGASUS_TEST_ASSERT(class1.getMethodCount() ==1);
// Test the findMethod and isMethod functions
PEGASUS_TEST_ASSERT(class1.findMethod(
CIMName ("isActive")) != PEG_NOT_FOUND);
PEGASUS_TEST_ASSERT(class1.findMethod(
CIMName ("DoesNotExist")) == PEG_NOT_FOUND);
PEGASUS_TEST_ASSERT(class1.findMethod(
CIMName ("isActive")) != PEG_NOT_FOUND);
PEGASUS_TEST_ASSERT(class1.findMethod(
CIMName ("DoesNotExist")) == PEG_NOT_FOUND);
// Now add another method and reconfirm.
class1.addMethod(CIMMethod(CIMName ("makeActive"), CIMTYPE_BOOLEAN)
.addParameter(CIMParameter(CIMName ("hostname"), CIMTYPE_STRING))
.addParameter(CIMParameter(CIMName ("port"), CIMTYPE_UINT32)));
PEGASUS_TEST_ASSERT(class1.getMethodCount() == 2);
// Test the findMethod and isMethod functions
// with two methods defined
PEGASUS_TEST_ASSERT(class1.findMethod(
CIMName ("isActive")) != PEG_NOT_FOUND);
PEGASUS_TEST_ASSERT(class1.findMethod(
CIMName ("makeActive")) != PEG_NOT_FOUND);
PEGASUS_TEST_ASSERT(class1.findMethod(
CIMName ("DoesNotExist")) == PEG_NOT_FOUND);
PEGASUS_TEST_ASSERT(class1.findMethod(
CIMName ("isActive")) != PEG_NOT_FOUND);
PEGASUS_TEST_ASSERT(class1.findMethod(
CIMName ("makeActive")) != PEG_NOT_FOUND);
PEGASUS_TEST_ASSERT(class1.findMethod(
CIMName ("DoesNotExist")) == PEG_NOT_FOUND);
// Test RemoveMethod function
Uint32 posMethod;
posMethod = class1.findMethod(CIMName ("isActive"));
PEGASUS_TEST_ASSERT(posMethod != PEG_NOT_FOUND);
class1.removeMethod(posMethod);
PEGASUS_TEST_ASSERT(class1.findMethod(
CIMName ("isActive")) == PEG_NOT_FOUND);
PEGASUS_TEST_ASSERT(class1.getMethodCount() == 1);
//ATTN: P3 TODO add tests for different case names
//Qualifier manipulation tests (find, remove)
PEGASUS_TEST_ASSERT(class1.findQualifier(CIMName ("q1")) != PEG_NOT_FOUND);
PEGASUS_TEST_ASSERT(class1.findQualifier(CIMName ("q2")) != PEG_NOT_FOUND);
PEGASUS_TEST_ASSERT(class1.findQualifier(CIMName ("qx")) == PEG_NOT_FOUND);
PEGASUS_TEST_ASSERT(class1.findQualifier(CIMName ("q1")) != PEG_NOT_FOUND);
PEGASUS_TEST_ASSERT(class1.findQualifier(CIMName ("q2")) != PEG_NOT_FOUND);
PEGASUS_TEST_ASSERT(class1.findQualifier(
CIMName ("association")) != PEG_NOT_FOUND);
PEGASUS_TEST_ASSERT(class1.isAssociation());
// Remove middle Qualifier "q2"
Uint32 posQualifier;
posQualifier = class1.findQualifier(CIMName ("q2"));
CIMConstQualifier qconst = class1.getQualifier(posQualifier);
PEGASUS_TEST_ASSERT(class1.getQualifierCount() == 3);
PEGASUS_TEST_ASSERT(posQualifier <= class1.getQualifierCount());
class1.removeQualifier(posQualifier);
PEGASUS_TEST_ASSERT(class1.getQualifierCount() == 2);
PEGASUS_TEST_ASSERT(class1.findQualifier(CIMName ("q2")) == PEG_NOT_FOUND);
PEGASUS_TEST_ASSERT(class1.findQualifier(CIMName ("q1")) != PEG_NOT_FOUND);
PEGASUS_TEST_ASSERT(class1.isAssociation());
// Remove the first parameter "q1"
posQualifier = class1.findQualifier(CIMName ("q1"));
PEGASUS_TEST_ASSERT(class1.getQualifierCount() == 2);
CIMQualifier cq = class1.getQualifier( class1.findQualifier(
CIMName ("q1")));
PEGASUS_TEST_ASSERT(posQualifier <= class1.getQualifierCount());
class1.removeQualifier(posQualifier);
PEGASUS_TEST_ASSERT(class1.getQualifierCount() == 1);
PEGASUS_TEST_ASSERT(class1.findQualifier(CIMName ("q1")) == PEG_NOT_FOUND);
PEGASUS_TEST_ASSERT(class1.findQualifier(CIMName ("q2")) == PEG_NOT_FOUND);
PEGASUS_TEST_ASSERT(class1.isAssociation());
// ATTH: P3 Add tests for try block for outofbounds
//The property manipulation tests.
PEGASUS_TEST_ASSERT(class1.findProperty(
CIMName ("count")) != PEG_NOT_FOUND);
PEGASUS_TEST_ASSERT(class1.findProperty(
CIMName ("message")) != PEG_NOT_FOUND);
PEGASUS_TEST_ASSERT(class1.findProperty(
CIMName ("isActive")) == PEG_NOT_FOUND);
PEGASUS_TEST_ASSERT(class1.getPropertyCount() == 2);
Uint32 posProperty;
posProperty = class1.findProperty(CIMName ("count"));
CIMConstProperty constprop = class1.getProperty(posProperty);
PEGASUS_TEST_ASSERT(constprop.getClassOrigin() == CIMName("YourClass"));
PEGASUS_TEST_ASSERT(constprop.getPropagated());
class1.removeProperty(posProperty);
PEGASUS_TEST_ASSERT(class1.findProperty(
CIMName ("message")) != PEG_NOT_FOUND);
PEGASUS_TEST_ASSERT(class1.findProperty(
CIMName ("count")) == PEG_NOT_FOUND);
PEGASUS_TEST_ASSERT(class1.getPropertyCount() == 1);
CIMProperty cp = class1.getProperty( class1.findProperty
(CIMName ("message")));
PEGASUS_TEST_ASSERT(cp.getClassOrigin().isNull());
PEGASUS_TEST_ASSERT(!cp.getPropagated());
if(verbose)
{
XmlWriter::printClassElement(class1);
MofWriter::printClassElement(class1);
}
Buffer out;
MofWriter::appendClassElement(out, class1);
out.clear();
XmlWriter::appendClassElement(out, class1);
PEGASUS_TEST_ASSERT(!class1.isAbstract());
CIMName squal("q1");
PEGASUS_TEST_ASSERT(class1.findQualifier(squal) == PEG_NOT_FOUND);
PEGASUS_TEST_ASSERT(!class1.hasKeys());
Array<CIMName> keyNames;
class1.getKeyNames(keyNames);
CIMClass c2(CIMName ("MyClass"));
PEGASUS_TEST_ASSERT(c2.getClassName().equal(CIMName ("myclass")));
// Error uninitialized handle
c2.setSuperClassName(CIMName ("CIM_Element"));
PEGASUS_TEST_ASSERT(c2.getSuperClassName() == CIMName ("CIM_Element"));
CIMClass c3 = c2.clone();
c3 = c2;
try
{
CIMMethod cm = c2.getMethod(0);
}
catch(IndexOutOfBoundsException& e)
{
if(verbose)
cout << "Exception: " << e.getMessage() << endl;
}
const CIMClass c4(CIMName ("MyClass"), CIMName ("YourClass"));
CIMConstClass c5(CIMName ("MyClass"), CIMName ("YourClass"));
CIMConstClass c6(CIMName ("MyClass"));
CIMConstClass cc7(c6);
CIMClass c7 = c5.clone();
const CIMClass c8(class1);
// Test the findMethod and isMethod functions
PEGASUS_TEST_ASSERT(c7.findMethod(
CIMName ("DoesNotExist")) == PEG_NOT_FOUND);
PEGASUS_TEST_ASSERT(c7.findQualifier(CIMName ("dummy")) == PEG_NOT_FOUND);
try
{
CIMConstMethod cm = c8.getMethod(0);
}
catch(IndexOutOfBoundsException& e)
{
if(verbose)
cout << "Exception: " << e.getMessage() << endl;
}
try
{
CIMConstProperty ccp = c8.getProperty(c8.findProperty
(CIMName ("count")));
}
catch(IndexOutOfBoundsException& e)
{
if(verbose)
cout << "Exception: " << e.getMessage() << endl;
}
if(verbose)
{
XmlWriter::printClassElement(c5);
}
try
{
CIMConstMethod cm = cc7.getMethod(0);
}
catch(IndexOutOfBoundsException& e)
{
if(verbose)
cout << "Exception: " << e.getMessage() << endl;
}
// Test the findMethod and isMethod functions
PEGASUS_TEST_ASSERT(c4.findMethod(
CIMName ("DoesNotExist")) == PEG_NOT_FOUND);
//Qualifier manipulation tests (find, remove)
PEGASUS_TEST_ASSERT(c4.findQualifier(CIMName ("qx")) == PEG_NOT_FOUND);
PEGASUS_TEST_ASSERT(c4.findQualifier(CIMName ("q1")) == PEG_NOT_FOUND);
PEGASUS_TEST_ASSERT(c4.findQualifier(CIMName ("q2")) == PEG_NOT_FOUND);
PEGASUS_TEST_ASSERT(c4.findQualifier(
CIMName ("association")) == PEG_NOT_FOUND);
posProperty = c4.findProperty(CIMName ("count"));
try
{
CIMConstQualifier ccq = c4.getQualifier(c4.findQualifier
(CIMName ("q1")));
}
catch (IndexOutOfBoundsException& e)
{
if(verbose)
cout << "Exception: " << e.getMessage() << endl;
}
PEGASUS_TEST_ASSERT(c4.findProperty(CIMName ("count")) == PEG_NOT_FOUND);
PEGASUS_TEST_ASSERT(c4.getClassName() == CIMName ("MyClass"));
PEGASUS_TEST_ASSERT(c4.getClassName().equal(CIMName ("MyClass")));
PEGASUS_TEST_ASSERT(c4.getClassName().equal(CIMName ("MYCLASS")));
PEGASUS_TEST_ASSERT(c4.getClassName().equal(CIMName ("myclass")));
PEGASUS_TEST_ASSERT(!c4.getClassName().equal(CIMName ("blob")));
PEGASUS_TEST_ASSERT(c4.getSuperClassName() == CIMName ("YourClass"));
// test the setSuperClassName function
/* ATTN KS 29 April. This test has problems. Relook later.
Think test, not code.
c4.setSuperClassName(CIMName ("JunkClass"));
PEGASUS_TEST_ASSERT(c4.getSuperClassName() == CIMName ("JunkClass"));
c4.setSuperClassName(CIMName ("YourClass"));
*/
PEGASUS_TEST_ASSERT(c5.getSuperClassName() == CIMName ("YourClass"));
PEGASUS_TEST_ASSERT(c5.getQualifierCount() == 0);
posQualifier = c5.findQualifier(CIMName ("q2"));
// throws out of bounds
try
{
CIMConstQualifier qconst1 = c5.getQualifier(posQualifier);
}
catch(IndexOutOfBoundsException& e)
{
if(verbose)
cout << "Exception: " << e.getMessage() << endl;
}
if(verbose)
{
cout << "All tests" << endl;
}
}
void GSVertexTrace::FindMinMax(const void* vertex, const uint32* index, int count)
{
const GSDrawingContext* context = m_state->m_context;
int n = 1;
switch(primclass)
{
case GS_POINT_CLASS:
n = 1;
break;
case GS_LINE_CLASS:
case GS_SPRITE_CLASS:
n = 2;
break;
case GS_TRIANGLE_CLASS:
n = 3;
break;
}
GSVector4 tmin = s_minmax.xxxx();
GSVector4 tmax = s_minmax.yyyy();
GSVector4i cmin = GSVector4i::xffffffff();
GSVector4i cmax = GSVector4i::zero();
#if _M_SSE >= 0x401
GSVector4i pmin = GSVector4i::xffffffff();
GSVector4i pmax = GSVector4i::zero();
#else
GSVector4 pmin = s_minmax.xxxx();
GSVector4 pmax = s_minmax.yyyy();
#endif
const GSVertex* RESTRICT v = (GSVertex*)vertex;
for(int i = 0; i < count; i += n)
{
if(primclass == GS_POINT_CLASS)
{
GSVector4i c(v[index[i]].m[0]);
if(color)
{
cmin = cmin.min_u8(c);
cmax = cmax.max_u8(c);
}
if(tme)
{
if(!fst)
{
GSVector4 stq = GSVector4::cast(c);
GSVector4 q = stq.wwww();
stq = (stq.xyww() * q.rcpnr()).xyww(q);
tmin = tmin.min(stq);
tmax = tmax.max(stq);
}
else
{
GSVector4i uv(v[index[i]].m[1]);
GSVector4 st = GSVector4(uv.uph16()).xyxy();
tmin = tmin.min(st);
tmax = tmax.max(st);
}
}
GSVector4i xyzf(v[index[i]].m[1]);
GSVector4i xy = xyzf.upl16();
GSVector4i z = xyzf.yyyy();
#if _M_SSE >= 0x401
GSVector4i p = xy.blend16<0xf0>(z.uph32(xyzf));
pmin = pmin.min_u32(p);
pmax = pmax.max_u32(p);
#else
GSVector4 p = GSVector4(xy.upl64(z.srl32(1).upl32(xyzf.wwww())));
pmin = pmin.min(p);
pmax = pmax.max(p);
#endif
}
else if(primclass == GS_LINE_CLASS)
{
GSVector4i c0(v[index[i + 0]].m[0]);
GSVector4i c1(v[index[i + 1]].m[0]);
if(color)
{
if(iip)
{
cmin = cmin.min_u8(c0.min_u8(c1));
cmax = cmax.max_u8(c0.max_u8(c1));
}
else
{
cmin = cmin.min_u8(c1);
cmax = cmax.max_u8(c1);
}
}
if(tme)
{
if(!fst)
{
GSVector4 stq0 = GSVector4::cast(c0);
GSVector4 stq1 = GSVector4::cast(c1);
GSVector4 q = stq0.wwww(stq1).rcpnr();
stq0 = (stq0.xyww() * q.xxxx()).xyww(stq0);
stq1 = (stq1.xyww() * q.zzzz()).xyww(stq1);
tmin = tmin.min(stq0.min(stq1));
tmax = tmax.max(stq0.max(stq1));
}
else
{
GSVector4i uv0(v[index[i + 0]].m[1]);
GSVector4i uv1(v[index[i + 1]].m[1]);
GSVector4 st0 = GSVector4(uv0.uph16()).xyxy();
GSVector4 st1 = GSVector4(uv1.uph16()).xyxy();
tmin = tmin.min(st0.min(st1));
tmax = tmax.max(st0.max(st1));
}
}
GSVector4i xyzf0(v[index[i + 0]].m[1]);
GSVector4i xyzf1(v[index[i + 1]].m[1]);
GSVector4i xy0 = xyzf0.upl16();
GSVector4i z0 = xyzf0.yyyy();
GSVector4i xy1 = xyzf1.upl16();
GSVector4i z1 = xyzf1.yyyy();
#if _M_SSE >= 0x401
GSVector4i p0 = xy0.blend16<0xf0>(z0.uph32(xyzf0));
GSVector4i p1 = xy1.blend16<0xf0>(z1.uph32(xyzf1));
pmin = pmin.min_u32(p0.min_u32(p1));
pmax = pmax.max_u32(p0.max_u32(p1));
#else
GSVector4 p0 = GSVector4(xy0.upl64(z0.srl32(1).upl32(xyzf0.wwww())));
GSVector4 p1 = GSVector4(xy1.upl64(z1.srl32(1).upl32(xyzf1.wwww())));
pmin = pmin.min(p0.min(p1));
pmax = pmax.max(p0.max(p1));
#endif
}
else if(primclass == GS_TRIANGLE_CLASS)
{
GSVector4i c0(v[index[i + 0]].m[0]);
GSVector4i c1(v[index[i + 1]].m[0]);
GSVector4i c2(v[index[i + 2]].m[0]);
if(color)
{
if(iip)
{
cmin = cmin.min_u8(c2).min_u8(c0.min_u8(c1));
cmax = cmax.max_u8(c2).max_u8(c0.max_u8(c1));
}
else
{
cmin = cmin.min_u8(c2);
cmax = cmax.max_u8(c2);
}
}
if(tme)
{
if(!fst)
{
GSVector4 stq0 = GSVector4::cast(c0);
GSVector4 stq1 = GSVector4::cast(c1);
GSVector4 stq2 = GSVector4::cast(c2);
GSVector4 q = stq0.wwww(stq1).xzww(stq2).rcpnr();
stq0 = (stq0.xyww() * q.xxxx()).xyww(stq0);
stq1 = (stq1.xyww() * q.yyyy()).xyww(stq1);
stq2 = (stq2.xyww() * q.zzzz()).xyww(stq2);
tmin = tmin.min(stq2).min(stq0.min(stq1));
tmax = tmax.max(stq2).max(stq0.max(stq1));
}
else
{
GSVector4i uv0(v[index[i + 0]].m[1]);
GSVector4i uv1(v[index[i + 1]].m[1]);
GSVector4i uv2(v[index[i + 2]].m[1]);
GSVector4 st0 = GSVector4(uv0.uph16()).xyxy();
GSVector4 st1 = GSVector4(uv1.uph16()).xyxy();
GSVector4 st2 = GSVector4(uv2.uph16()).xyxy();
tmin = tmin.min(st2).min(st0.min(st1));
tmax = tmax.max(st2).max(st0.max(st1));
}
}
GSVector4i xyzf0(v[index[i + 0]].m[1]);
GSVector4i xyzf1(v[index[i + 1]].m[1]);
GSVector4i xyzf2(v[index[i + 2]].m[1]);
GSVector4i xy0 = xyzf0.upl16();
GSVector4i z0 = xyzf0.yyyy();
GSVector4i xy1 = xyzf1.upl16();
GSVector4i z1 = xyzf1.yyyy();
GSVector4i xy2 = xyzf2.upl16();
GSVector4i z2 = xyzf2.yyyy();
#if _M_SSE >= 0x401
GSVector4i p0 = xy0.blend16<0xf0>(z0.uph32(xyzf0));
GSVector4i p1 = xy1.blend16<0xf0>(z1.uph32(xyzf1));
GSVector4i p2 = xy2.blend16<0xf0>(z2.uph32(xyzf2));
pmin = pmin.min_u32(p2).min_u32(p0.min_u32(p1));
pmax = pmax.max_u32(p2).max_u32(p0.max_u32(p1));
#else
GSVector4 p0 = GSVector4(xy0.upl64(z0.srl32(1).upl32(xyzf0.wwww())));
GSVector4 p1 = GSVector4(xy1.upl64(z1.srl32(1).upl32(xyzf1.wwww())));
GSVector4 p2 = GSVector4(xy2.upl64(z2.srl32(1).upl32(xyzf2.wwww())));
pmin = pmin.min(p2).min(p0.min(p1));
pmax = pmax.max(p2).max(p0.max(p1));
#endif
}
else if(primclass == GS_SPRITE_CLASS)
{
GSVector4i c0(v[index[i + 0]].m[0]);
GSVector4i c1(v[index[i + 1]].m[0]);
if(color)
{
if(iip)
{
cmin = cmin.min_u8(c0.min_u8(c1));
cmax = cmax.max_u8(c0.max_u8(c1));
}
else
{
cmin = cmin.min_u8(c1);
cmax = cmax.max_u8(c1);
}
}
if(tme)
{
if(!fst)
{
GSVector4 stq0 = GSVector4::cast(c0);
GSVector4 stq1 = GSVector4::cast(c1);
GSVector4 q = stq1.wwww().rcpnr();
stq0 = (stq0.xyww() * q).xyww(stq1);
stq1 = (stq1.xyww() * q).xyww(stq1);
tmin = tmin.min(stq0.min(stq1));
tmax = tmax.max(stq0.max(stq1));
}
else
{
GSVector4i uv0(v[index[i + 0]].m[1]);
GSVector4i uv1(v[index[i + 1]].m[1]);
GSVector4 st0 = GSVector4(uv0.uph16()).xyxy();
GSVector4 st1 = GSVector4(uv1.uph16()).xyxy();
tmin = tmin.min(st0.min(st1));
tmax = tmax.max(st0.max(st1));
}
}
GSVector4i xyzf0(v[index[i + 0]].m[1]);
GSVector4i xyzf1(v[index[i + 1]].m[1]);
GSVector4i xy0 = xyzf0.upl16();
GSVector4i z0 = xyzf0.yyyy();
GSVector4i xy1 = xyzf1.upl16();
GSVector4i z1 = xyzf1.yyyy();
#if _M_SSE >= 0x401
GSVector4i p0 = xy0.blend16<0xf0>(z0.uph32(xyzf1));
GSVector4i p1 = xy1.blend16<0xf0>(z1.uph32(xyzf1));
pmin = pmin.min_u32(p0.min_u32(p1));
pmax = pmax.max_u32(p0.max_u32(p1));
#else
GSVector4 p0 = GSVector4(xy0.upl64(z0.srl32(1).upl32(xyzf1.wwww())));
GSVector4 p1 = GSVector4(xy1.upl64(z1.srl32(1).upl32(xyzf1.wwww())));
pmin = pmin.min(p0.min(p1));
pmax = pmax.max(p0.max(p1));
#endif
}
}
#if _M_SSE >= 0x401
pmin = pmin.blend16<0x30>(pmin.srl32(1));
pmax = pmax.blend16<0x30>(pmax.srl32(1));
#endif
GSVector4 o(context->XYOFFSET);
GSVector4 s(1.0f / 16, 1.0f / 16, 2.0f, 1.0f);
m_min.p = (GSVector4(pmin) - o) * s;
m_max.p = (GSVector4(pmax) - o) * s;
if(tme)
{
if(fst)
{
s = GSVector4(1.0f / 16, 1.0f).xxyy();
}
else
{
s = GSVector4(1 << context->TEX0.TW, 1 << context->TEX0.TH, 1, 1);
}
m_min.t = tmin * s;
m_max.t = tmax * s;
}
else
{
m_min.t = GSVector4::zero();
m_max.t = GSVector4::zero();
}
if(color)
{
m_min.c = cmin.zzzz().u8to32();
m_max.c = cmax.zzzz().u8to32();
}
else
{
m_min.c = GSVector4i::zero();
m_max.c = GSVector4i::zero();
}
}
int main(int argc, char* args[]) {
Renderer* renderer = new Renderer();
if(!renderer->init()) {
printf( "Failed to initialize!\n" );
} else {
Character* c = new Character(new Texture("res/img/dot.bmp", 200, 200));
renderer->addTexture(new Texture("res/img/waterlevel2.png", 0, 0));
renderer->render();
renderer->addTexture(c->getTexture());
bool quit = false;
SDL_Event e;
LoadCollisionMap lcm;
list<Circle> circlesList;
circlesList = lcm.load();
list<Circle> l;
Circle c1(200,0,10);
l.push_back(c1);
CollisionDetector cd;
int y = 0;
while(!cd.hasCollision(circlesList, l)) {
l.pop_back();
y += 1;
Circle c1(200,y,10);
l.push_back(c1);
}
y -= 1;
c->setPosX(200);
c->setPosY(y);
renderer->render();
int mVelX = 0;
int DOT_VEL = 1;
while(!quit) {
while(SDL_PollEvent(&e) != 0) {
if(e.type == SDL_QUIT) {
quit = true;
}
if(e.type == SDL_KEYDOWN && e.key.repeat == 0) {
switch(e.key.keysym.sym) {
case SDLK_LEFT: mVelX -= DOT_VEL; break;
case SDLK_RIGHT: mVelX += DOT_VEL; break;
}
} else if(e.type == SDL_KEYUP && e.key.repeat == 0) {
switch(e.key.keysym.sym) {
case SDLK_LEFT: mVelX += DOT_VEL; break;
case SDLK_RIGHT: mVelX -= DOT_VEL; break;
}
}
}
c->setPosX(c->getPosX() + mVelX);
LoadCollisionMap lcm;
list<Circle> circlesList;
circlesList = lcm.load();
int mPosX = c->getPosX();
int mPosY = c->getPosY();
list<Circle> l;
Circle c1(mPosX,mPosY,10);
l.push_back(c1);
CollisionDetector cd;
int y = mPosY;
while(cd.hasCollision(circlesList, l)) {
l.pop_back();
y -= 1;
Circle c1(mPosX,y,10);
l.push_back(c1);
};
while(!cd.hasCollision(circlesList, l)) {
l.pop_back();
y += 1;
Circle c1(mPosX,y,10);
l.push_back(c1);
};
c->setPosY(y);
renderer->render();
}
}
return 0;
}
