TEST(CollectionUtilsTest, vecShiftLeftByMoreThanSize) {
typedef std::vector<size_t> Vec;
Vec vec;
vec.push_back('a');
vec.push_back('b');
vec.push_back('c');
vec.push_back('d');
vec.push_back('e');
vec.push_back('f');
vec.push_back('g');
Vec leftBy10;
leftBy10.push_back('d');
leftBy10.push_back('e');
leftBy10.push_back('f');
leftBy10.push_back('g');
leftBy10.push_back('a');
leftBy10.push_back('b');
leftBy10.push_back('c');
Vec actual = vec;
VectorUtils::shiftLeft(actual, 10);
ASSERT_TRUE(std::equal(leftBy10.begin(), leftBy10.end(), actual.begin()));
}
Vec ASSR::initial_state_mean()const {
Vec ans = StateSpaceModelBase::initial_state_mean();
double y0 = StateSpaceModelBase::observation_matrix(0).dot(ans);
ans.push_back(y0);
ans.push_back(0.0);
return ans;
}
TEST(CollectionUtilsTest, vecShiftRightBy2) {
typedef std::vector<size_t> Vec;
Vec vec;
vec.push_back('a');
vec.push_back('b');
vec.push_back('c');
vec.push_back('d');
vec.push_back('e');
vec.push_back('f');
vec.push_back('g');
Vec rightBy2;
rightBy2.push_back('f');
rightBy2.push_back('g');
rightBy2.push_back('a');
rightBy2.push_back('b');
rightBy2.push_back('c');
rightBy2.push_back('d');
rightBy2.push_back('e');
Vec actual = vec;
VectorUtils::shiftRight(actual, 2);
ASSERT_TRUE(std::equal(rightBy2.begin(), rightBy2.end(), actual.begin()));
}
TEST(VecOpr,throwtest){
Vec A;
Vec B;
for(int i=0;i<10;i++){
A.push_back(Rand(engine));
EXPECT_THROW((A)+(B),Exception<Vec>);
EXPECT_THROW((A)-(B),Exception<Vec>);
EXPECT_THROW(SqDistance((A),(B)),Exception<Vec>);
EXPECT_THROW(Distance((A),(B)),Exception<Vec>);
B.push_back(Rand(engine));
EXPECT_NO_THROW((A)+(B));
EXPECT_NO_THROW((A)-(B));
EXPECT_NO_THROW(SqDistance((A),(B)));
EXPECT_NO_THROW(Distance((A),(B)));
}
A.clear();B.clear();
for(int i=0;i<10;i++){
B.push_back(Rand(engine));
EXPECT_THROW((A)+(B),Exception<Vec>);
EXPECT_THROW((A)-(B),Exception<Vec>);
A.push_back(Rand(engine));
EXPECT_NO_THROW((A)+(B));
EXPECT_NO_THROW((A)-(B));
}
}
TEST(VecOpr,Add_Sub){
Vec A;
Vec B;
for(int i=0;i<10;i++){
for(double c=-10;c<=10;c+=1){
EXPECT_TRUE(((A)+(B)).size()==A.size());
EXPECT_TRUE(((A)-(B)).size()==A.size());
}
A.push_back(Rand(engine));
B.push_back(Rand(engine));
}
A.clear();
B.clear();
for(int i=0;i<10;i++){
for(double c=-10;c<=10;c+=1){
Vec C=(A)+(B);
Vec D=(C)-(B);
for(size_t i=0,n=A.size();i<n;i++){
EXPECT_TRUE(D[i]==A[i]);
EXPECT_TRUE(C[i]==(A[i]+B[i]));
}
}
A.push_back(Rand(engine));
B.push_back(Rand(engine));
}
}
void Lib::sortedUnique(int n, double *x, Vec& uv)
{
uv.clear();
if(n==0) return;
typedef std::vector<double>::size_type vec_sz;
//copy x into vector xv
Vec xv(n);
vec_sz nv = (vec_sz)n;
for(vec_sz i=0;i<nv;i++) xv[i] = *(x+i);
//sort xv
std::sort(xv.begin(),xv.end());
//get unique values of xv into uv
uv.push_back(xv[0]);
vec_sz nu = 1;
double ov = uv[0];
for(vec_sz i=1;i<nv;i++) {
if(xv[i] != ov) {
ov = xv[i];
uv.push_back(ov);
}
}
}
TEST(RectDimensions,WhereIntersects_throwing2){
RectDimensions A;
Vec O;Vec D;
for(size_t i=1;i<10;i++){
A<<make_pair(-10.0+i,double(i));
EXPECT_THROW(A.WhereIntersects((O),(D)),Exception<RectDimensions>);
D.push_back(0);
EXPECT_THROW(A.WhereIntersects((O),(D)),Exception<RectDimensions>);
O.push_back(0);
EXPECT_TRUE(A.WhereIntersects((O),(D)).surface==RectDimensions::None);
}
}
void Lib::acov(Vec& x,int nl, Vec& acov, bool cor)
{
typedef Vec::size_type ST;
double c;
int n = (int)x.size();
double m = mean(x);
acov.clear();
for(int i=0;i<=nl;i++)
{
c=0.0;
for(int j=0;j<(n-i);j++) c += (x[j]-m)*(x[j+i]-m);
acov.push_back(c);
}
if(cor)
{
double c0 = acov[0];
for(int i=0;i<=nl;i++)
{
acov[i] = acov[i]/c0;
}
}
else
for(int i=0;i<=nl;i++) acov[i] /= n;
}
int main(int argc, const char *argv[])
{
Vec<Student_info> students;
Student_info record;
string::size_type maxlen = 0;
while (record.read(cin)) {
maxlen = max(maxlen, record.name().size());
students.push_back(record);
}
//
sort(students.begin(), students.end(), compare);
for (Vec<double>::size_type i = 0; i != students.size(); i++) {
cout << students[i].name() << string(maxlen + 1 - students[i].name().size(), ' ');
try {
double final_grade = students[i].grade();
streamsize prec = cout.precision();
cout << setprecision(3) << final_grade << setprecision(prec) << endl;
} catch (domain_error e) {
cout << e.what() << endl;
}
}
return 0;
}
int main(){
int cases=0;
while(1){
int n,q;
cin>>n>>q;
if(n==0) break;
++cases;
cout<<"CASE# "<<cases<<":"<<endl;
marble.clear();
int k;
for(int i=0;i<n;++i) {cin>>k;marble.push_back(k);}
sort(marble.begin(),marble.end());
for(int i=0;i<q;i++){
cin>>k;
Vec::iterator it=lower_bound(marble.begin(),marble.end(), k);
if(it!=marble.end() && *it==k){
cout<<k<<" found at "<<it-marble.begin()+1<<endl;
}else{
cout<<k<<" not found"<<endl;
}
}
}
return 0;
}
Vec ArModel::simulate(int n, const Vec &y0) const {
if(y0.size() != number_of_lags()){
ostringstream err;
err << "Error in ArModel::simulate." << endl
<< "Initial state value y0 was size " << y0.size()
<< ", but the model has " << number_of_lags() << " lags."
<< endl;
report_error(err.str());
}
const Vec &phi(this->phi());
std::deque<double> lags(y0.rbegin(), y0.rend());
Vec ans;
ans.reserve(n);
for(int i = 0; i < n; ++i) {
double mu = 0;
for(int lag = 0; lag < number_of_lags(); ++lag) {
mu += phi[lag] * lags[lag];
}
double y = rnorm(mu, sigma());
lags.push_front(y);
lags.pop_back();
ans.push_back(y);
}
return ans;
}
int main()
{
int H, W, x;
while (cin >> H >> W, H) {
Vec subT;
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
cin >> x;
if (x == 1) {
subT.push_back(i * W + j);
}
}
}
Graph G(H * W, Vec(H * W));
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
for (int k = 0; k < H; k++) {
for (int l = 0; l < W; l++) {
G[i * W + j][k * W + l] = get_dist(i, j, k, l);
}
}
}
}
cout << H * W - minimum_steiner_tree(G, subT) << endl;
}
return 0;
}
TEST(CollectionUtilsTest, vecShiftLeftBySize) {
typedef std::vector<size_t> Vec;
Vec vec;
vec.push_back('a');
vec.push_back('b');
vec.push_back('c');
vec.push_back('d');
vec.push_back('e');
vec.push_back('f');
vec.push_back('g');
Vec actual = vec;
VectorUtils::shiftLeft(actual, vec.size());
ASSERT_TRUE(std::equal(vec.begin(), vec.end(), actual.begin()));
}
void TestTransform()
{
typedef vector<int> Vec;
Vec test1;
Vec checked1;
Vec checked;
for(int i = 1; i < 5; i++)
{
test1.push_back (i * i); // test1: 1 4 9 16
checked1.push_back (i * i);
}
//vector<int> test2(test1.size());
//transform(test1.begin(), test1.end(), test2.begin(), [](int i){return ++i;}); // test2: 2 5 10 17
Vec test2p;
transform(test1.begin(), test1.end(), back_inserter(test2p), [](int i){return ++i;}); // test2: 2 5 10 17
cout << "Unary operation, the first is the same: ";
checked.push_back(2);
checked.push_back(5);
checked.push_back(10);
checked.push_back(17);
CHECK_RESULTS(IsEqual(test1, checked1));
cout << "Unary operation, the second has changed: ";
CHECK_RESULTS(IsEqual(test2p, checked));
cout << "Binary operation, the first is the same: ";
checked.clear();
checked.push_back(3);
checked.push_back(9);
checked.push_back(19);
checked.push_back(33);
transform(test1.begin(), test1.end(), test2p.begin(), test2p.begin(), [](int i, int j){return i + j;}); // test1: 3 9 19 33
CHECK_RESULTS(IsEqual(test1, checked1));
cout << "Binary operation, the second has changed: ";
CHECK_RESULTS(IsEqual(test2p, checked));
cout << "No elements: ";
test1.erase(test1.begin(), test1.end());
checked.erase(checked.begin(), checked.end());
test2p.erase(test2p.begin(), test2p.end());
transform(test1.begin(), test1.end(), back_inserter(test2p),[](int i){return ++i;});
CHECK_RESULTS(IsEqual(test2p, checked));
}
Vec<string> getVec(istream &is)
{
Vec<string> svec;
string s;
while (is >> s)
svec.push_back(s);
return svec;
}
void nextFr(int* recPar, int* recNode,int recS ,int offset, int* parents, Vec &Fr )
{
for (int i = 0; i < recS; i++)
if (parents[recNode[i]-offset] == -1){
Fr.push_back(recNode[i]);
parents[recNode[i]-offset] = recPar[i];
}
}
int main(int argc, char* argv[])
{
int rank,size,offset;
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &size);
ostringstream convert;
convert << rank+1;
string file = "data"+ convert.str();
int numLocal, totalNode;
Graph g(rank,file);
Matpair buf(4);
Vec F;
numLocal = g.localNode();
offset = rank*numLocal;
int root = 512;
int finish,localfinish;
int parents[numLocal];
for (int i=0;i<numLocal;i++){
parents[i] = -1;
}
if (rank == root/numLocal){
F.push_back(root);
parents[root-offset] = -2;}
localfinish = !F.empty();
Vec nxFr;
int dep=0;
int depth[numLocal];
for (int i = 0; i < numLocal; i++){
depth[i]=0;
}
while(1){
localfinish=!F.empty();
MPI_Barrier(MPI_COMM_WORLD);
MPI_Allreduce(&localfinish,&finish,1,MPI_INT,MPI_SUM,MPI_COMM_WORLD);
if (finish==0)
break;
if (!F.empty()){
for (Vec::iterator i = F.begin();i != F.end(); i++){
depth[*i-offset] = dep+1;
cout << "node "<< *i <<" depth: "<<dep+1<<endl;
}
}
nextFrBuf(g,F,rank,size,buf,offset);
alltoallPersonalized(buf,parents,nxFr,size,offset);
F=nxFr;
dep++;
}
MPI_Finalize();
return 0;
}
Vec NetworkLayer:: getOutput(){
Vec output;
for(int i=0;i<Neurons.size();i++){
output.push_back(Neurons[i].getOutput());
}
return output;
}
TEST(VecOpr,Distances){
Vec A;
Vec B;
for(int i=0;i<10;i++){
for(double c=-10;c<=10;c+=1){
double d=Distance((A),(B));
EXPECT_TRUE(d>=0);
EXPECT_TRUE(sqrt(SqDistance((A),(B)))==d);
}
A.push_back(Rand(engine));
B.push_back(Rand(engine));
}
A.clear();
B.clear();
A.push_back(Rand(engine));
B.push_back(Rand(engine));
EXPECT_TRUE(SqDistance((A),(B))==pow(A[0]-B[0],2));
}
//template definition
void calculatePseudo(typename Kernel::Vector& point, Vec& v1, typename Kernel::Vector& segment, Vec& v2) {
Vector3 dir = (segment.template head<3>() - segment.template tail<3>()).normalized();
Vector3 pp = segment.head(3) + (segment.head(3)-point.head(3)).norm()*dir;
#ifdef DCM_USE_LOGGING
if(!boost::math::isnormal(pp.norm()))
BOOST_LOG_SEV(log, error) << "Unnormal pseudopoint detected";
#endif
v2.push_back(pp);
};
int main()
{
Vec<int> ages;
ages.push_back(31);
ages.push_back(60);
ages.push_back(0);
ages.push_back(36);
ages.push_back(14);
ages.push_back(0);
Vec<int>::size_type n = ages.size();
ages[n-1] = 7;
ages.erase(2);
n = ages.size();
for (Vec<int>::size_type i = 0; i != n; i++)
cout << ages[i] << endl;
return 0;
}
TEST(VecOpr,Mul){
Vec A;
for(int i=0;i<10;i++){
for(double c=-10;c<=10;c+=1)
EXPECT_TRUE(((A)*c).size()==A.size());
A.push_back(Rand(engine));
}
A.clear();
for(int i=0;i<10;i++){
for(double c=-9.5;c<10;c+=1){//escape zero
Vec B=(A)*c;
Vec C=(B)*(1.0/c);
for(size_t i=0,n=A.size();i<n;i++){
EXPECT_TRUE(C[i]==A[i]);
EXPECT_TRUE(B[i]==(A[i]*c));
}
}
A.push_back(iRand(engine));
}
}
int PosCluster::removeOverlaps (int positionDistance)
{
debug_mustbe (positionDistance > 0);
if (size () <= 1)
return 0;
int lastStartPosition = INT_MAX;
//
// greedy algorithm -
// (1) the positions are ordered by starting positions
// (2) go from the end of the list to the beginning,
// adding a position iff it does not overlap
//
// same as the known activity-selection problem.
// this algorithm yields an optimal solution
//
Vec <const SeqPosition*> positions;
PositionSet::reverse_iterator revIt = _set.rbegin();
for (; revIt != _set.rend () ; ++revIt) {
//
//
const int currentPosition =
PositionComparator::strandPos (*revIt);
const int currentFinishPosition =
PositionComparator::strandPos (*revIt, positionDistance);
//
//
if (currentFinishPosition > lastStartPosition) {
//
// this is an overlap, we should remove this position
positions.push_back ((*revIt));
}
else {
//
// we are keeping this position, we are not keeping any other positions
// that start before the feature starting here ends
lastStartPosition = currentPosition;
}
}
//
// now after we have decided which positions to remove, we actually
// do the removing
int size = positions.size ();
for (int i=0 ; i<size ; i++) {
removePosition (positions [i]);
}
//
// that's it, we have removed all overlaps!!!
debug_mustbe (this->size () >= 1);
return size;
}
void AbstractMultiInput::OneChannelEnd(){
m_state--;
if(m_state==0){
Vec values;
for(auto slot:m_input_slots)
values.push_back(slot->Value());
Process(values);
Finish();
}
if(m_state<0)
throw Exception<AbstractMultiInput>("MultiInput error: state changed to an invalid value.");
}
void IterTest::iter3()
{
typedef vector<const char*> Vec;
Vec v; // Vector of character strings.
v.push_back("zippy"); // First element.
v.push_back("motorboy"); // Second element.
Vec::reverse_iterator it;
unsigned counter = 0;
for (it = v.rbegin(); it != v.rend(); ++it, ++counter) {
switch (counter) {
case 1:
CPPUNIT_ASSERT(!strcmp(*it, "zippy"));
break;
case 0:
CPPUNIT_ASSERT(!strcmp(*it, "motorboy"));
break;
default:
CPPUNIT_FAIL;
}
}
}
int main(){
int kase =0;
while(true){
int c,s,q;
cin>>c>>s>>q;
if (c==0) break;
++kase;
edges.clear();
for(int i=0;i<s;++i){
Edge e;
cin>>e.from>>e.to>>e.weight;
edges.push_back(e);
}
sort(edges.begin(), edges.end());
for(int i=1;i<=c;++i){
nodes[i].parent = nodes+i;
nodes[i].count = 0;
nodes[i].edges.clear();
}
int count =0;
for(Vec::iterator it = edges.begin(); count< c-1 && it!= edges.end(); ++it){
Node *rs = getRoot(it->from), *rt = getRoot(it->to);
if(rs == rt) continue;
if (rs->count > rt->count){
rt->parent = rs;
rs->count+=rt->count;
} else {
rs->parent = rt;
rt->count += rs->count;
}
++count;
nodes[it->from].edges.push_back(*it);
int tmp = it->to;
it->to = it->from; it->from =tmp;
nodes[it->from].edges.push_back(*it);
}
if (kase >1) cout<<endl;
cout<<"Case #"<<kase<<endl;
for(int i=0;i<q; ++i){
int s,t;
cin>>s>>t;
CalcResult result = calc(s,t,0);
if (result.reached) {
cout<<result.value<<endl;
} else {
cout<<"no path"<<endl;
}
}
}
return 0;
}
int main()
{
Vec<char> v = {'H', 'e', 'l', 'l', 'o', ',', 'w', 'o', 'r', 'l', 'd', '!'};
for(const auto &c : v)
cout << c;
cout << endl;
v.push_back(':');
v.push_back(')');
cout << v.size() << endl;
cout << v.capacity() << endl;
for(auto iter = v.begin(); iter != v.end(); ++iter)
cout << *iter;
cout << endl;
return 0;
}
void Lib::batchMeans(Vec& x, int bsize, Vec& means)
{
means.clear();
int n = (int)x.size();
bool someleft = (n>=bsize);
int nbatch=0;
while(someleft)
{
double sum = 0.0;
int off = nbatch*bsize;
for(int i=0;i<bsize;i++) sum += x[off+i];
means.push_back(sum/bsize);
nbatch += 1;
someleft = (n>=(bsize)*(nbatch+1));
}
}
TEST(RectDimensions,IsInside){
RectDimensions A;
for(size_t i=1;i<10;i++){
A<<make_pair(-10.0+i,double(i));
for(size_t cnt=0;cnt<(500*i);cnt++){
bool test=true;
Vec v;
for(size_t j=0,n=A.NumberOfDimensions();j<n;j++){
double x=Rand(engine);
test&=(x>=A.Dimension(j).first)&&(x<=A.Dimension(j).second);
EXPECT_THROW(A.IsInside((v)),Exception<RectDimensions>);
v.push_back(x);
}
EXPECT_TRUE(A.IsInside((v))==test);
}
}
}
int main()
{
//test example
Vec<int> data;
for (int i = 0; i < 30000; i++)
data.push_back(i);
std::cout << data[29999] << std::endl;
// for (int i = 0; i < 10; i++)
// std::cout << data[i] << std::endl;
//
// data.erase(data.begin(), data.begin() + 1);
// for (int i = 0; i < 9; i++)
// std::cout << data[i] << std::endl;
// data.clear();
return 0;
}