void askStr()
{
int str;
printf("Integer:\n");
scanf("%d",&str);
insertRear(str);
displayArray();
}
main()
{
int numbers [size][size]=
{
{-1000,-1000,-1000,-1000,-1000},
{-1000,1,1,1,-1000},
{-1000,1,1,1,-1000},
{-1000,1,1,1,-1000},
{-1000,-1000,-1000,-1000,-1000}
};
getArray(numbers);
displayArray(numbers);
getchar();
}
//-----------------------------------------------------------------------------
// Tools::displayDataItem
//-----------------------------------------------------------------------------
std::string Tools::displayDataItem( const IDataItemPtr& item, std::string indent)
{
stringstream res;
res<<indent<<"DataItem name: "<<item->getName()<<endl;
res<<indent<<" short name: "<<item->getShortName()<<endl;
res<<indent<<" Physical location: "<<item->getLocation()<<endl;
res<<indent<<" Rank: "<<item->getRank();
res<<" Shape: "<<displayArray( item->getShape() );
res<<" Nb element: "<<item->getSize();
res<<" Type: "<<item->getType().name()<<std::endl;
std::list<IAttributePtr> list_attr = item->getAttributeList();
if( list_attr.size() > 0 )
{
res<<indent<<" - getAttributeList: ";
int i = 0;
for( std::list<IAttributePtr>::iterator iter = list_attr.begin(); iter != list_attr.end(); iter++)
{
if( iter != list_attr.begin() )
res<<", ";
if( i > 0 && i % 10 == 0 )
res<<std::endl<<indent<<" ";
res<<(*iter)->getName();
i++;
}
res<<std::endl;
}
std::list<IDimensionPtr> list_dim = item->getDimensionList();
if( list_dim.size() > 0 )
{
res<<indent<<" - getDimensionList: ";
int i = 0;
for( std::list<IDimensionPtr>::iterator iter = list_dim.begin(); iter != list_dim.end(); iter++)
{
if( iter != list_dim.begin() )
res<<", ";
if( i > 0 && i % 10 == 0 )
res<<std::endl<<indent<<" ";
res<<(*iter)->getName();
i++;
}
res<<std::endl;
}
return res.str();
}
int main (void)
{
int originalArray[4][5] =
{
{ 0, 1, 2, 3, 4 },
{ 4, 3, 2, 1, 0 },
{ 10, 20, 30, 40, 50 },
{ 50, 40, 30, 20, 10 }
};
int newArray[5][4];
void displayArray (int array[5][4]);
void transposeArray ( int array1[4][5], int array2[5][4], int rows, int columns );
printf("Transposed matrix:\n");
transposeArray ( originalArray, newArray, 4, 5 );
displayArray ( newArray );
return 0;
}
void bubbleSort(int arr[], int size)
{
int y = 1;
int x = 0;
int sorted = 0;
while(sorted == 0)
{
sorted = 1;
for(x = 0; x < (size - y); x++)
{
displayArray(arr, size);
if(arr[x+1] < arr[x])
{
int temp = arr[x+1];
arr[x+1] = arr[x];
arr[x] = temp;
sorted = 0;
}
}
y++;
}
}
void askUser()
{
int num;
int x=10;
int i;
char choices;
struct node *current;
current=head;
system("cls");
printf("\n[1]-ENQUEUE\n[2]-DEQUEUE\n[3]-FRONT\n[4]-REAR\n");
choices=getch();
switch(choices)
{
case '1':
num=askNum();
for(i=0;i<num;i++)
{
while(x<0||x>9)
{
printf("Enter number: ");
scanf("%d",&x);
}
insertRear(x);
x=10;
displayArray();
}
getch();
askUser();
break;
case '2':
deleteFront();
displayArray();
getch();
askUser();
break;
case '3':
if(head!=NULL)
{
printf("%d",head->data);
}
else
{
printf("List is empty");
}
getch();
askUser();
break;
case '4':
while(current->next!=NULL)
{
current=current->next;
}
printf("%d",current->data);
getch();
askUser();
break;
default:
getch();
break;
}
}
void askUser()
{
int num;
int x=10;
int i;
char choices;
system("cls");
printf("\n[1]-DISPLAY ARRAY\n[2]-INSERT REAR\n[3]-INSERT FRONT\n[4]-INSERT INTO\n[5]-DELETE FRONT\n[6]-DELETE REAR\n[7]-DELETE ITEM\n[8]-DELETE ALL ITEM\n[9]-MAKE UNIQUE\n");
choices=getch();
switch(choices)
{
case '1':
displayArray();
getch();
askUser();
break;
case '2':
num=askNum();
for(i=0;i<num;i++)
{
while(x<0||x>9)
{
printf("Enter number: ");
scanf("%d",&x);
}
insertRear(x);
x=10;
displayArray();
}
getch();
askUser();
break;
case '3':
num=askNum();
for(i=0;i<num;i++)
{
while(x<0||x>9)
{
printf("Enter number: ");
scanf("%d",&x);
}
insertFront(x);
x=10;
displayArray();
}
getch();
askUser();
break;
case '4':
displayArray();
insertInto();
displayArray();
getch();
askUser();
break;
case '5':
deleteFront();
displayArray();
getch();
askUser();
break;
case '6':
deleteRear();
displayArray();
getch();
askUser();
break;
case '7':
displayArray();
deleteItem();
displayArray();
getch();
askUser();
break;
case '8':
displayArray();
deleteAllItem();
displayArray();
getch();
askUser();
break;
case '9':
displayArray();
makeUnique();
displayArray();
getch();
askUser();
break;
default:
getch();
break;
}
}
int main(int argc, char* argv[])
{
const char* executable_tracking = getenv("XALT_EXECUTABLE_TRACKING");
if (executable_tracking == NULL || (strcmp(executable_tracking,"yes") != 0))
{
std::cout << "*------------------------------------------------------------------------------*\n";
std::cout << " Warning: XALT_EXECUTABLE_TRACKING is not set to \"yes\"!!\n";
std::cout << "\n";
std::cout << " XALT will not do anything without this variable\n";
std::cout << " set to \"yes\"\n";
std::cout << "*------------------------------------------------------------------------------*\n";
return 1;
}
std::string syshost(xalt_syshost());
std::string syslog_tag("XALT_LOGGING_");
syslog_tag.append(syshost);
Vstring resultA;
std::string cmd = XALT_DIR "/bin/xalt_print_os";
capture(cmd, resultA);
std::string current_os_descript = resultA[0];
char dateStr[dateSZ];
time_t now = (time_t) epoch();
strftime(dateStr,dateSZ, "%c", localtime(&now));
const char* transmission = getenv("XALT_TRANSMISSION_STYLE");
if (transmission == NULL)
transmission = TRANSMISSION;
if ((strcasecmp(transmission,"file") != 0 ) &&
(strcasecmp(transmission,"none") != 0 ) &&
(strcasecmp(transmission,"syslog") != 0 ) &&
(strcasecmp(transmission,"syslogv1") != 0 ) &&
(strcasecmp(transmission,"direct2db") != 0 ))
transmission = "file";
const char* computeSHA1 = getenv("XALT_COMPUTE_SHA1");
if (computeSHA1 == NULL)
computeSHA1 = XALT_COMPUTE_SHA1;
const char* xalt_etc_dir = getenv("XALT_ETC_DIR");
if (xalt_etc_dir == NULL)
xalt_etc_dir = XALT_ETC_DIR;
const char* xalt_mpi_tracking = getenv("XALT_MPI_TRACKING");
if (xalt_mpi_tracking == NULL)
xalt_mpi_tracking = XALT_MPI_TRACKING;
const char* xalt_gpu_tracking = getenv("XALT_GPU_TRACKING");
if (xalt_gpu_tracking == NULL)
xalt_gpu_tracking = XALT_GPU_TRACKING;
if (strcmp(HAVE_DCGM,"no") == 0)
xalt_gpu_tracking = HAVE_DCGM;
const char* xalt_func_tracking = getenv("XALT_FUNCTION_TRACKING");
if (xalt_func_tracking == NULL)
xalt_func_tracking = XALT_FUNCTION_TRACKING;
else if (strcmp(xalt_func_tracking,"no") != 0)
xalt_func_tracking = "yes";
const char* xalt_scalar_tracking = getenv("XALT_SCALAR_TRACKING");
if (xalt_scalar_tracking == NULL)
xalt_scalar_tracking = XALT_SCALAR_TRACKING;
const char* xalt_scalar_sampling = getenv("XALT_SCALAR_SAMPLING");
if (!xalt_scalar_sampling)
xalt_scalar_sampling = getenv("XALT_SCALAR_AND_SPSR_SAMPLING");
if (xalt_scalar_sampling == NULL || strcmp(xalt_scalar_sampling,"yes") != 0)
xalt_scalar_sampling = "no";
const char* xalt_preload_only = XALT_PRELOAD_ONLY;
std::string cxx_ld_library_path = CXX_LD_LIBRARY_PATH;
if (cxx_ld_library_path == "")
cxx_ld_library_path = "<empty>";
if (argc == 2 && strcmp(argv[1],"--json") == 0)
{
Json json;
json.add("DATE", dateStr);
json.add("XALT_EXECUTABLE_TRACKING", executable_tracking);
json.add("XALT_PRELOAD_ONLY", xalt_preload_only);
json.add("XALT_SYSHOST", syshost);
json.add("XALT_VERSION", XALT_VERSION);
json.add("XALT_INTERFACE_VERSION", XALT_INTERFACE_VERSION);
json.add("XALT_GIT_VERSION", XALT_GIT_VERSION);
json.add("XALT_VERSION_STR", XALT_VERSION_STR);
json.add("XALT_FILE_PREFIX", XALT_FILE_PREFIX);
json.add("XALT_TRANSMISSION_STYLE", transmission);
json.add("XALT_FUNCTION_TRACKING", xalt_func_tracking);
if (strcmp(transmission,"syslog") == 0)
json.add("XALT_LOGGING_TAG", syslog_tag);
json.add("XALT_COMPUTE_SHA1", computeSHA1);
json.add("XALT_ETC_DIR", xalt_etc_dir);
json.add("XALT_DIR", XALT_DIR);
json.add("BAD_INSTALL", BAD_INSTALL);
json.add("XALT_CONFIG_PY", XALT_CONFIG_PY);
json.add("XALT_SYSTEM_PATH", XALT_SYSTEM_PATH);
json.add("XALT_SYSHOST_CONFIG", SYSHOST_CONFIG);
json.add("XALT_MPI_TRACKING", xalt_mpi_tracking);
json.add("XALT_GPU_TRACKING", xalt_gpu_tracking);
json.add("XALT_SCALAR_TRACKING", xalt_scalar_tracking);
json.add("XALT_SCALAR_SAMPLING", xalt_scalar_sampling);
json.add("XALT_SYSLOG_MSG_SZ", SYSLOG_MSG_SZ);
json.add("XALT_INSTALL_OS", XALT_INSTALL_OS);
json.add("XALT_CURRENT_OS", current_os_descript);
json.add("CXX_LD_LIBRARY_PATH", cxx_ld_library_path);
json.add("HAVE_32BIT", HAVE_32BIT);
json.add("MY_HOSTNAME_PARSER", MY_HOSTNAME_PARSER);
json.add("HAVE_DCGM", HAVE_DCGM);
json.add("hostnameA", hostnameSz, hostnameA);
json.add("pathPatternA", pathPatternSz, pathPatternA);
json.add("envPatternA", envPatternSz, envPatternA);
json.fini();
std::string jsonStr = json.result();
std::cout << jsonStr << std::endl;
return 0;
}
std::cout << "*------------------------------------------------------------------------------*\n";
std::cout << " XALT Configuration Report\n";
std::cout << "*------------------------------------------------------------------------------*\n\n";
std::cout << "Today's DATE: " << dateStr << "\n";
std::cout << "XALT_VERSION: " << XALT_VERSION << "\n";
std::cout << "XALT_GIT_VERSION: " << XALT_GIT_VERSION << "\n";
std::cout << "XALT_VERSION_STR: " << XALT_VERSION_STR << "\n";
std::cout << "*------------------------------------------------------------------------------*\n";
std::cout << "XALT_EXECUTABLE_TRACKING: " << executable_tracking << "\n";
std::cout << "XALT_FUNCTION_TRACKING: " << xalt_func_tracking << "\n";
std::cout << "XALT_SYSHOST: " << syshost << "\n";
std::cout << "XALT_FILE_PREFIX: " << XALT_FILE_PREFIX << "\n";
std::cout << "XALT_INTERFACE_VERSION: " << XALT_INTERFACE_VERSION << "\n";
std::cout << "XALT_TRANSMISSION_STYLE: " << transmission << "\n";
if (strcmp(transmission,"syslog") == 0)
std::cout << "XALT_LOGGING_TAG: " << syslog_tag << "\n";
std::cout << "XALT_COMPUTE_SHA1: " << computeSHA1 << "\n";
std::cout << "XALT_ETC_DIR: " << xalt_etc_dir << "\n";
std::cout << "XALT_DIR: " << XALT_DIR << "\n";
std::cout << "BAD_INSTALL: " << BAD_INSTALL << "\n";
std::cout << "XALT_CONFIG_PY: " << XALT_CONFIG_PY << "\n";
std::cout << "XALT_MPI_TRACKING: " << xalt_mpi_tracking << "\n";
std::cout << "XALT_GPU_TRACKING: " << xalt_gpu_tracking << "\n";
std::cout << "XALT_SCALAR_TRACKING: " << xalt_scalar_tracking << "\n";
std::cout << "XALT_SCALAR_SAMPLING: " << xalt_scalar_sampling << "\n";
std::cout << "XALT_SYSTEM_PATH: " << XALT_SYSTEM_PATH << "\n";
std::cout << "XALT_SYSHOST_CONFIG: " << SYSHOST_CONFIG << "\n";
std::cout << "XALT_SYSLOG_MSG_SZ: " << SYSLOG_MSG_SZ << "\n";
std::cout << "CXX_LD_LIBRARY_PATH: " << cxx_ld_library_path << "\n";
std::cout << "XALT_INSTALL_OS: " << XALT_INSTALL_OS << "\n";
std::cout << "CURRENT_OS: " << current_os_descript << "\n";
std::cout << "XALT_PRELOAD_ONLY: " << XALT_PRELOAD_ONLY << "\n";
std::cout << "HAVE_32BIT: " << HAVE_32BIT << "\n";
std::cout << "MY_HOSTNAME_PARSER: " << MY_HOSTNAME_PARSER << "\n";
std::cout << "Built with DCGM: " << HAVE_DCGM << "\n";
std::cout << "*------------------------------------------------------------------------------*\n\n";
displayArray("hostnameA", hostnameSz, hostnameA);
std::cout << "\nRemember that \"PKGS\" means a program that can also track internal packages\n";
displayArray("pathPatternA", pathPatternSz, pathPatternA);
displayArray("envPatternA", envPatternSz, envPatternA);
std::cout << "*----------------------*\n";
std::cout << " Array: interval\n";
std::cout << "*----------------------*\n";
for (int i = 0; i < rangeSz-1; ++i)
std::cout << "Time Range(seconds): [" << rangeA[i].left << ", " << rangeA[i+1].left
<< "]: probability: "<< rangeA[i].prob << "\n";
std::cout << "\n";
return 0;
}
int main(int argc,char **argv){
int vector[5]={1,2,3,4,5};
displayArray(vector,5);
return 0;
}
