void test9(void) {
ElementNode_handle pE1=0,pE2=0,pRes;
int i;
printf("\n==== VECTOR ADDITION 2 =================\n");
for(i=0;i<5;++i) insert_element(&pE1,2000*i,i);
for(i=0;i<10;++i) insert_element(&pE2,1000*i,i);
pRes=add(pE1,pE2);
printf("pE1 + pE2 = \n");
printf("raw:\n"); print_elements(pRes); printf("\n");
free_elements(pRes);
pRes=add(pE2,pE1);
printf("pE2 + pE1 = \n");
printf("raw:\n"); print_elements(pRes); printf("\n");
free_elements(pRes);
pRes=add(pE1,pE1);
printf("pE1 + pE1 = \n");
printf("raw:\n"); print_elements(pRes); printf("\n");
free_elements(pRes);
free_elements(pE1);
free_elements(pE2);
}
void test10( void )
{
ElementNode * pE1=0, *pE2=0, *pRes;
int i;
printf( "\n==== VECTOR ADDITION (ZEROES) ========\n" );
for( i=0; i<20; ++i ) insert_element( &pE1,i,i*i );
printf( "vector pE1 formatted:\n" );
printf_elements( pE1,"%4d",20 );
printf( "\n" );
for( i=0; i<20; ++i ) insert_element( &pE2,i,-i*i );
printf( "vector pE2 formatted:\n" );
printf_elements( pE2,"%4d",20 );
printf( "\n" );
pRes=add( pE1,pE2 );
printf( "pE1 + pE2 = \n" );
printf_elements( pRes,"%4d",20 );
printf( "\n" );
printf( "raw:\n" );
print_elements( pRes );
printf( "\n" );
free_elements( pRes );
pRes=add( pE2,pE1 );
printf( "pE2 + pE1 = \n" );
printf_elements( pRes,"%4d",20 );
printf( "\n" );
printf( "raw:\n" );
print_elements( pRes );
printf( "\n" );
free_elements( pRes );
free_elements( pE1 );
free_elements( pE2 );
}
int main()
{
// create array of four seasons
boost::array<std::string,4> seasons = {
{ "spring", "summer", "autumn", "winter" }
};
// copy and change order
boost::array<std::string,4> seasons_orig = seasons;
for (unsigned i=seasons.size()-1; i>0; --i) {
std::swap(seasons.at(i),seasons.at((i+1)%seasons.size()));
}
std::cout << "one way: ";
print_elements(seasons);
// try swap()
std::cout << "other way: ";
std::swap(seasons,seasons_orig);
print_elements(seasons);
// try reverse iterators
std::cout << "reverse: ";
for (boost::array<std::string,4>::reverse_iterator pos
=seasons.rbegin(); pos<seasons.rend(); ++pos) {
std::cout << " " << *pos;
}
std::cout << std::endl;
return 0; // makes Visual-C++ compiler happy
}
int main()
{
vector<int> coll;
insert_elements(coll, 1, 9);
print_elements(coll, "coll: ");
// shuffle all elements randomly
random_shuffle(coll.begin(), coll.end());
print_elements(coll, "shuffled: ");
// sort them again
sort(coll.begin(), coll.end());
print_elements(coll, "sorted: ");
// shuffle elements with default engine
default_random_engine dre;
shuffle(coll.begin(), coll.end(), dre);
print_elements(coll, "shuffled: ");
MyRandom rd;
random_shuffle(coll.begin(), coll.end(), rd);
print_elements(coll, "own random engine shuffled result: ");
}
static int compare_elements(
IDirect3DVertexDeclaration9 *decl,
const D3DVERTEXELEMENT9 *expected_elements) {
HRESULT hr;
unsigned int i, size;
D3DVERTEXELEMENT9 last = D3DDECL_END();
D3DVERTEXELEMENT9 *elements = NULL;
/* How many elements are there? */
hr = IDirect3DVertexDeclaration9_GetDeclaration( decl, NULL, &size );
ok(SUCCEEDED(hr), "GetDeclaration returned %#x, expected %#x\n", hr, D3D_OK);
if (FAILED(hr)) goto fail;
/* Allocate buffer */
elements = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(D3DVERTEXELEMENT9) * size);
ok (elements != NULL, "Out of memory, aborting test\n");
if (elements == NULL) goto fail;
/* Get the elements */
hr = IDirect3DVertexDeclaration9_GetDeclaration( decl, elements, &size);
ok(SUCCEEDED(hr), "GetDeclaration returned %#x, expected %#x\n", hr, D3D_OK);
if (FAILED(hr)) goto fail;
/* Compare one by one */
for (i = 0; i < size; i++) {
int status;
int end1 = memcmp(&elements[i], &last, sizeof(D3DVERTEXELEMENT9));
int end2 = memcmp(&expected_elements[i], &last, sizeof(D3DVERTEXELEMENT9));
status = ((end1 && !end2) || (!end1 && end2));
ok (!status, "Mismatch in size, test declaration is %s than expected\n",
(end1 && !end2) ? "shorter" : "longer");
if (status) { print_elements(elements); goto fail; }
status = memcmp(&elements[i], &expected_elements[i], sizeof(D3DVERTEXELEMENT9));
ok (!status, "Mismatch in element %d\n", i);
if (status) { print_elements(elements); goto fail; }
}
HeapFree(GetProcessHeap(), 0, elements);
return S_OK;
fail:
HeapFree(GetProcessHeap(), 0, elements);
return E_FAIL;
}
/***********************************************************************//**
* @brief Print matrix
***************************************************************************/
std::string GMatrix::print(void) const
{
// Initialise result string
std::string result;
// Append header
result.append("=== GMatrix ===");
result.append("\n"+parformat("Number of rows")+str(m_rows));
if (m_rowsel != NULL) {
result.append(" (compressed "+str(m_num_rowsel)+")");
}
result.append("\n"+parformat("Number of columns")+str(m_cols));
if (m_colsel != NULL) {
result.append(" (compressed "+str(m_num_colsel)+")");
}
result.append("\n"+parformat("Number of elements")+str(m_elements));
result.append("\n"+parformat("Number of allocated cells")+str(m_alloc));
// Append elements and compression schemes
result.append(print_elements());
result.append(print_row_compression());
result.append(print_col_compression());
// Return result
return result;
}
int main()
{
ElementNode_handle pE1=0;
int i;
printf("\n====== INSERTS BACK =============================\n");
insert_element(&pE1,10,10);
insert_element(&pE1,11,11);
insert_element(&pE1,9,9);
insert_element(&pE1,4,4);
insert_element(&pE1,3,3);
insert_element(&pE1,5,5);
insert_element(&pE1,2,2);
insert_element(&pE1,7,7);
insert_element(&pE1,4,1);
insert_element(&pE1,12,12);
insert_element(&pE1,17,17);
insert_element(&pE1,13,13);
insert_element(&pE1,20,20);
insert_element(&pE1,30,30);
insert_element(&pE1,25,25);
printf("vector 1 formatted: %p \n", &pE1);
printf_elements(pE1,"%4d",80); printf("\n");
printf("vector 1 raw:\n");
print_elements(pE1); printf("\n");
i = get(pE1, 4);
printf ("%i",i);
return 0;
}
void print_rows(ConstRowNode_handle p_r) {
while (p_r) {
printf("row %i: ", p_r->pos);
print_elements(p_r->elements);
printf("\n");
p_r = p_r->next;
}
}
void KlassInfoHisto::print_histo_on(outputStream* st, bool print_stats,
bool csv_format, const char *columns) {
if (print_stats) {
print_class_stats(st, csv_format, columns);
} else {
st->print_cr("%s",title());
print_elements(st);
}
}
void test3(void) {
ElementNode_handle pE2=0;
int i;
printf("\n====== DELETE FRONT ====================\n");
for(i=0;i<5;++i) insert_element(&pE2,i,i+1); /*no 0s in the list*/
printf("vector 2 formatted:\n");
printf_elements(pE2,"%4d",5); printf("\n");
printf("vector 2 raw:\n");
print_elements(pE2); printf("\n");
delete_element(&pE2,0);
printf("vector 2 formatted:\n");
printf_elements(pE2,"%4d",5); printf("\n");
printf("vector 2 raw:\n");
print_elements(pE2); printf("\n");
free_elements(pE2);
}
int main()
{
vector<string> coll1 = { "Hello", "this", "is", "an", "example" };
list<string> coll2;
// 使用插入式代替赋值式
copy(coll1.cbegin(), coll1.cend(),
back_inserter(coll2));
copy(coll2.cbegin(), coll2.cend(),
ostream_iterator<string>(cout, " "));
cout << endl;
copy(coll1.crbegin(), coll1.crend(),
coll2.begin());
copy(coll2.cbegin(), coll2.cend(),
ostream_iterator<string>(cout, " "));
cout << endl;
// initialize source collection with "..........abcdef.........."
vector<char> source(10, '.');
for (int c = 'a'; c <= 'f'; c++) {
source.push_back(c);
}
source.insert(source.end(), 10, '.');
print_elements(source, "source: ");
// copy all letters three elements in front of the 'a'
vector<char> c1(source.cbegin(), source.cend());
copy(c1.cbegin() + 10, c1.cbegin() + 16, // source range
c1.begin() + 7); // destination range
print_elements(c1, "c1: ");
// 从后向前挨个复制，与上述copy复制的方向相反
vector<char> c2(source.cbegin(), source.cend());
copy_backward(c2.cbegin() + 10, c2.cbegin() + 16, // source range
c2.begin() + 19); // destination range
print_elements(c2, "c2: ");
}
void KlassInfoHisto::print_histo_on(outputStream* st, bool print_stats,
bool csv_format, const char *columns) {
if (print_stats) {
print_class_stats(st, csv_format, columns);
} else {
st->print_cr(" num #instances #bytes class name (module)");
st->print_cr("-------------------------------------------------------");
print_elements(st);
}
}
void test12(void) {
ElementNode_handle pE1=0;
int pos=10000;
printf("\n==== TESTING FIND 2 ========\n");
insert_element(&pE1,pos,5);
print_elements(pE1); printf("\n");
printf ("value %i at position %i\n",get(pE1,pos),pos);
free_elements(pE1);
}
void test0(void) {
ElementNode_handle pE1=0;
int i;
printf("\n====== INSERTS BACK =============================\n");
for(i=0;i<20;++i) insert_element(&pE1,3*i,i*i);
printf("vector 1 formatted:\n");
printf_elements(pE1,"%4d",80); printf("\n");
printf("vector 1 raw:\n");
print_elements(pE1); printf("\n");
free_elements(pE1);
}
void test1(void) {
ElementNode_handle pE2=0;
int i;
printf("\n====== INSERTS BACK =============================\n");
for(i=0;i<20;++i) insert_element(&pE2,20-i,i);
printf("vector 2 formatted:\n");
printf_elements(pE2,"%4d",20); printf("\n");
printf("vector 2 raw:\n");
print_elements(pE2); printf("\n");
free_elements(pE2);
}
int main(){
int arr[] = {10, 20, 3, 5, 1, 2, 6, 8, 9, 40 };
int size = sizeof(arr)/sizeof(arr[0]);
printf ("%d elements to be sorted using selection sort\n", size);
SelectionSort(arr, size);
printf ("Array Elements after Selection Sort: ");
print_elements(arr, size);
return 0;
}
std::string Info::print_region_tree(const Region& region, Uint level)
{
std::string tree;
for (Uint i=0; i<level; i++)
tree += " ";
tree += region.name() + " (" + to_str(region.recursive_elements_count()) + ")\n";
tree += print_elements(region,level+1);
boost_foreach( const Region& subregion, find_components_with_filter<Region>(region,IsComponentTrue()))
{
tree += print_region_tree(subregion,level+1);
}
void test2(void) {
ElementNode_handle pE3=0;
int i;
printf("\n====== INSERTS MIDDLE =============================\n");
for(i=0;i<20;++i) {
if (i%2) insert_element(&pE3,i,i);
else insert_element(&pE3,20-i,-i);
}
printf("vector 3 formatted:\n");
printf_elements(pE3,"%4d",20); printf("\n");
printf("vector 3 raw:\n");
print_elements(pE3); printf("\n");
free_elements(pE3);
}
int main()
{
vector<int> coll;
vector<int>::iterator pos;
insert_elements(coll, 1, 9);
print_elements(coll, "coll: ");
// define an object for the predicate (using a lambda)
auto isEven = [](int elem) {
return elem % 2 == 0;
};
// print whether all, any, or none of the elements are/is even
cout << boolalpha << "all even?: "
<< all_of(coll.cbegin(), coll.cend(), isEven) << endl;
cout << "any even?: "
<< any_of(coll.cbegin(), coll.cend(), isEven) << endl;
cout << "none even?: "
<< none_of(coll.cbegin(), coll.cend(), isEven) << endl;
}
void KlassInfoHisto::print_on(outputStream* st) const {
st->print_cr("%s",title());
print_elements(st);
}
