int main()
{
vector<int> vec(10); // default initialized to 0
fill(vec.begin(), vec.end(), 1); // reset each element to 1
// sum the elements in vec starting the summation with the value 0
int sum = accumulate(vec.cbegin(), vec.cend(), 0);
cout << sum << endl;
// set a subsequence of the container to 10
fill(vec.begin(), vec.begin() + vec.size()/2, 10);
cout << accumulate(vec.begin(), vec.end(), 0) << endl;
// reset the same subsequence to 0
fill_n(vec.begin(), vec.size()/2, 0);
cout << accumulate(vec.begin(), vec.end(), 0) << endl;
// create 10 elements on the end of vec each with the value 42
fill_n(back_inserter(vec), 10, 42);
cout << accumulate(vec.begin(), vec.end(), 0) << endl;
// concatenate elements in a vector of strings and store in sum
vector<string> v;
string s;
while (cin >> s)
v.push_back(s);
string concat = accumulate(v.cbegin(), v.cend(), string(""));
cout << concat << endl;
return 0;
}
void operators_test() {
long xnr = 100;
long ynr = 10;
long nc = 10;
LDL_ts x(xnr,nc);
LDL_ts y(ynr,nc);
// gernate data
fill_n(x.getData(),x.nrow()*x.ncol(),100.0);
fill_n(y.getData(),y.nrow()*y.ncol(),5.0);
// generate dates
for(long xi = 0; xi < x.nrow(); xi++)
x.getDates()[xi] = xi;
// generate dates
for(long yi = 0; yi < y.nrow(); yi++)
y.getDates()[yi] = yi;
LDL_ts Zplus = x + y;
LDL_ts Zminus = x - y;
LDL_ts Zmultiplies = x * y;
LDL_ts Zdivides = x / y;
BOOST_CHECK_EQUAL( Zplus.nrow(), y.nrow() );
BOOST_CHECK_EQUAL( Zplus.ncol(), 10 );
BOOST_CHECK_EQUAL( Zminus.nrow(), y.nrow() );
BOOST_CHECK_EQUAL( Zminus.ncol(), 10 );
BOOST_CHECK_EQUAL( Zmultiplies.nrow(), y.nrow() );
BOOST_CHECK_EQUAL( Zmultiplies.ncol(), 10 );
BOOST_CHECK_EQUAL( Zdivides.nrow(), y.nrow() );
BOOST_CHECK_EQUAL( Zdivides.ncol(), 10 );
// add test for all== later
LDL_ts XplusS = x + 100.0;
LDL_ts SplusX = 100.0 + x;
LDL_ts XminusS = x - 100.0;
LDL_ts SminusX = 100.0 - x;
LDL_ts XmultS = x * 100.0;
LDL_ts SmultX = 100.0 * x;
LDL_ts XdivS = x / 100.0;
LDL_ts SdivX = 100.0 * x;
vector<bool> xb_eq_scalar = x == 10;
vector<bool> xb_neq_ts = x != y;
vector<bool> xb_gt_ts = x > y;
vector<bool> xb_gte_ts = x >= y;
vector<bool> xb_lt_ts = x < y;
vector<bool> xb_lte_ts = x <= y;
}
int main()
{
vector<int>ivec(10); //default initialized to 0
fill(ivec.begin(), ivec.end(), 1); //reset each element to 1
//print elements in ivec
auto iter = ivec.begin();
while (iter != ivec.end())
cout << *iter++ << " ";
cout << endl;
//sum the elements in ivec starting the summation with the value 0
int sum = accumulate(ivec.begin(), ivec.end(), 0);
cout << sum << endl;
//set a subsequence of the container to 10
fill(ivec.begin(), ivec.begin() + ivec.size() / 2, 10);
cout << accumulate(ivec.begin(), ivec.end(), 0) << endl;
//reset the same subsequence to 0
fill_n(ivec.begin(), ivec.size() / 2, 0);
cout << accumulate(ivec.begin(), ivec.end(), 0) << endl;
//concatenates elements in a vector of strings and store in sum
vector<string>v;
string s;
while (cin >> s)
v.push_back(s);
string concat = accumulate(v.begin(), v.end(), string(""));
cout << concat << endl;
getchar();
}
int main() {
vector<int> vec{1, 2, 3, 4, 5, 6};
fill_n(vec.begin(), vec.size(), 7);
for (auto i : vec)
cout << i << " ";
cout << endl;
return 0;
}
int main()
{
vector<int> vec{0,1,2,3,4,5,6,7,8,9};
fill_n(vec.begin(), vec.size(), 0);
for (auto i : vec)
cout << i << " ";
cout << endl;
}
int main()
{
vector<int> ivec = {1,2,3,4,5,6,7,8,9};
fill_n(ivec.begin(), ivec.size(), 0);
for(auto c : ivec)
cout << c << " ";
cout << endl;
return 0;
}
void mixed_operators_test() {
long xnr = 100;
long ynr = 10;
long nc = 10;
LDL_ts x(xnr,nc);
LIL_ts y(ynr,nc);
// gernate data
fill_n(x.getData(),x.nrow()*x.ncol(),100.0);
fill_n(y.getData(),y.nrow()*y.ncol(),5);
// generate dates
for(long xi = 0; xi < x.nrow(); xi++)
x.getDates()[xi] = xi;
// generate dates
for(long yi = 0; yi < y.nrow(); yi++)
y.getDates()[yi] = yi;
LDL_ts Zplus = x + y;
LDL_ts Zminus = x - y;
LDL_ts Zmultiplies = x * y;
LDL_ts Zdivides = x / y;
BOOST_CHECK_EQUAL( Zplus.nrow(), y.nrow() );
BOOST_CHECK_EQUAL( Zplus.ncol(), 10 );
BOOST_CHECK_EQUAL( Zminus.nrow(), y.nrow() );
BOOST_CHECK_EQUAL( Zminus.ncol(), 10 );
BOOST_CHECK_EQUAL( Zmultiplies.nrow(), y.nrow() );
BOOST_CHECK_EQUAL( Zmultiplies.ncol(), 10 );
BOOST_CHECK_EQUAL( Zdivides.nrow(), y.nrow() );
BOOST_CHECK_EQUAL( Zdivides.ncol(), 10 );
vector<bool> xb_eq_scalar = x == static_cast<int>(10);
vector<bool> xb_neq_ts = x != y;
vector<bool> xb_gt_ts = x > y;
vector<bool> xb_gte_ts = x >= y;
vector<bool> xb_lt_ts = x < y;
vector<bool> xb_lte_ts = x <= y;
}
template <typename T, typename MemoryBlock> void save(
archive& ar
, std::string const& path
, alps::numeric::matrix<T, MemoryBlock> const& m
, std::vector<std::size_t> size = std::vector<std::size_t>()
, std::vector<std::size_t> chunk = std::vector<std::size_t>()
, std::vector<std::size_t> offset = std::vector<std::size_t>()
) {
using std::copy;
using std::fill_n;
using alps::cast;
typedef typename alps::numeric::matrix<T,MemoryBlock>::const_col_element_iterator col_iterator;
if (is_continuous<T>::value && m.empty())
ar.write(path, static_cast<typename scalar_type<alps::numeric::matrix<T, MemoryBlock> >::type const *>(NULL), std::vector<std::size_t>());
else if (is_continuous<T>::value) {
std::vector<std::size_t> extent(get_extent(m));
copy(extent.begin(),extent.end(), std::back_inserter(size));
// We want to write one column:
chunk.push_back(1);
// How much memory does the column and the elements it contains need?
copy(extent.begin()+1,extent.end(), std::back_inserter(chunk));
std::size_t const offset_col_index = offset.size();
fill_n(std::back_inserter(offset), extent.size(), 0);
// Write column by column
for(std::size_t j=0; j < num_cols(m); ++j) {
offset[offset_col_index] = j;
ar.write(path, get_pointer(*(col(m, j).first)), size, chunk, offset);
}
} else if (m.empty())
ar.write(path, static_cast<int const *>(NULL), std::vector<std::size_t>());
else if (is_vectorizable(m)) {
size.push_back(num_cols(m));
size.push_back(num_rows(m));
// We want to write element by element:
chunk.push_back(1);
chunk.push_back(1);
std::size_t const offset_col_index = offset.size();
std::size_t const offset_row_index = offset.size()+1;
offset.push_back(0);
offset.push_back(0);
for(std::size_t j=0; j < num_cols(m); ++j) {
offset[offset_col_index] = j;
for(std::size_t i=0; i< num_rows(m); ++i) {
offset[offset_row_index] = i;
save(ar, path, m(i,j), size, chunk, offset);
}
}
} else {
if( ar.is_data(path) )
ar.delete_data(path);
for(std::size_t j=0; j < num_cols(m); ++j)
for(std::size_t i=0; i < num_rows(m); ++i)
save(ar, ar.complete_path(path) + "/" + cast<std::string>(j) + "/" + cast<std::string>(i), m(i,j) );
}
}
int main(void)
{
constexpr int size = 10;
vector<int> ivec(size);
fill_n(ivec.begin(), ivec.size(), 1);
for (const int i : ivec)
cout << i << " ";
cout << endl;
return 0;
}
void assignment_test() {
long xnr = 10;
long xnc = 2;
long ynr = 100;
long ync = 50;
LDL_ts x(xnr,xnc);
LDL_ts y(ynr,ync);
fill_n(x.getData(),x.nrow()*x.ncol(),1.0);
fill_n(y.getData(),y.nrow()*y.ncol(),2.0);
// test self assignment
x = x;
BOOST_CHECK_EQUAL(x.nrow(),xnr);
BOOST_CHECK_EQUAL(x.ncol(),xnc);
BOOST_CHECK_EQUAL(x.getData()[0],1.0);
// TS TS assignment
BOOST_CHECK_EQUAL(y.getData()[0],2.0);
y = x;
BOOST_CHECK_EQUAL(y.nrow(),xnr);
BOOST_CHECK_EQUAL(y.ncol(),xnc);
BOOST_CHECK_EQUAL(y.getData()[0],1.0);
x = 100.0;
// check that dims are same as before
BOOST_CHECK_EQUAL(x.nrow(),xnr);
BOOST_CHECK_EQUAL(x.ncol(),xnc);
// now all values of x shoud be == 100.0
for(long i = 0; i < x.nrow()*x.ncol(); i++) {
BOOST_CHECK_EQUAL(x.getData()[i],100);
}
}
int minCut(string s) {
const int n = s.size();
int f[n+1];
bool p[n][n];
fill_n(&p[0][0], n * n, false);
for (int i = 0; i <= n; i++)
f[i] = n - i - 1;
for (int i = n; i >= 0; i--) {
for (int j = i; j < n; j++) {
if (s[i] == s[j] && (j - i < 2 || p[i + 1][j - 1])) {
p[i][j] = true;
f[i] = min(f[i], f[j+1] + 1);
}
}
}
return f[0];
}
Registers::Registers()
{
// Set all registers to zero.
fill_n( registers_, 32, 0 );
regmap_["$zero"] = 0;
regmap_["$at"] = 1;
regmap_["$v0"] = 2;
regmap_["$v1"] = 3;
regmap_["$a0" ] = 4;
regmap_["$a1"] = 5;
regmap_["$a2"] = 6;
regmap_["$a3"] = 7;
regmap_["$t0" ] = 8;
regmap_["$t1"] = 9;
regmap_["$t2"] = 10;
regmap_["$t3"] = 11;
regmap_["$t4" ] = 12;
regmap_["$t5"] = 13;
regmap_["$t6"] = 14;
regmap_["$t7"] = 15;
regmap_["$s0" ] = 16;
regmap_["$s1"] = 17;
regmap_["$s2"] = 18;
regmap_["$s3"] = 19;
regmap_["$s4" ] = 20;
regmap_["$s5"] = 21;
regmap_["$s6"] = 22;
regmap_["$s7"] = 23;
regmap_["$t8" ] = 24;
regmap_["$t9"] = 25;
regmap_["$k0"] = 26;
regmap_["$k1"] = 27;
regmap_["$gp" ] = 28;
regmap_["$sp"] = 29;
regmap_["$fp"] = 30;
regmap_["$ra"] = 31;
}
// ********************************************************************************************
//
// ********************************************************************************************
AmbCodes::AmbCodes()
{
using std::fill_n;
fill_n(trans_amb_codes, 256, 0);
trans_amb_codes['Y'] = 2;
trans_amb_codes['R'] = 3;
trans_amb_codes['W'] = 4;
trans_amb_codes['S'] = 5;
trans_amb_codes['K'] = 6;
trans_amb_codes['M'] = 7;
trans_amb_codes['D'] = 8;
trans_amb_codes['V'] = 9;
trans_amb_codes['H'] = 10;
trans_amb_codes['B'] = 11;
trans_amb_codes['N'] = 12;
trans_amb_codes['X'] = 13;
trans_amb_codes['U'] = 14;
trans_amb_codes['.'] = 15;
trans_amb_codes['-'] = 16;
trans_amb_codes['A'] = 1;
trans_amb_codes['C'] = 1;
trans_amb_codes['T'] = 1;
trans_amb_codes['G'] = 1;
fill_n(untrans_amb_codes+128+ 0*8, 8, 'Y');
fill_n(untrans_amb_codes+128+ 1*8, 8, 'R');
fill_n(untrans_amb_codes+128+ 2*8, 8, 'W');
fill_n(untrans_amb_codes+128+ 3*8, 8, 'S');
fill_n(untrans_amb_codes+128+ 4*8, 8, 'K');
fill_n(untrans_amb_codes+128+ 5*8, 8, 'M');
fill_n(untrans_amb_codes+128+ 6*8, 8, 'D');
fill_n(untrans_amb_codes+128+ 7*8, 8, 'V');
fill_n(untrans_amb_codes+128+ 8*8, 8, 'H');
fill_n(untrans_amb_codes+128+ 9*8, 8, 'B');
fill_n(untrans_amb_codes+128+10*8, 8, 'N');
fill_n(untrans_amb_codes+128+11*8, 8, 'X');
fill_n(untrans_amb_codes+128+12*8, 8, 'U');
fill_n(untrans_amb_codes+128+13*8, 8, '.');
fill_n(untrans_amb_codes+128+14*8, 8, '-');
}