void Profiler::writeData() const
{
outStream.open(fileName, std::ios::trunc);
// Write category headers
for (uint i = 0; i < numUsedCategories; i++)
{
outStream << categories[i].name;
outStream << getDelimiter(i);
}
uint endIndex;
uint startIndex;
if (wrapped())
{
endIndex = frameIndex % MAX_FRAME_SAMPLES;
startIndex = (endIndex + 1) % MAX_FRAME_SAMPLES;
while (startIndex != endIndex)
{
writeFrame(startIndex);
startIndex = (startIndex + 1) % MAX_FRAME_SAMPLES;
}
if (currentFrameComplete())
writeFrame(startIndex);
}
else
{
uint numActualFrames = frameIndex;
if (currentFrameComplete())
numActualFrames++;
startIndex = 0;
endIndex = numActualFrames;
while (startIndex < endIndex)
writeFrame(startIndex++);
}
outStream.close();
}
bool FileSystem::rawopen
(
std::ofstream& out, // Output stream to open.
const string &fname, // May be converted to upper-case.
bool is_text // Should the file be opened in text mode
)
{
string name = fname;
if (!rewrite_virtual_path(name)) {
con.Print_err(MM_MAJOR_WARN, "Illegal file access\n");
return false;
}
#if defined(MACOS) || (__GNUG__ > 2)
std::ios_base::openmode mode = std::ios::out | std::ios::trunc;
if (!is_text) mode |= std::ios::binary;
#elif defined(UNIX)
int mode = std::ios::out | std::ios::trunc;
#else
int mode = std::ios::out | std::ios::trunc;
if (!is_text) mode |= std::ios::binary;
#endif
switch_slashes(name);
// We first "clear" the stream object. This is done to prevent
// problems when re-using stream objects
out.clear();
int uppercasecount = 0;
do {
out.open(name.c_str(), mode); // Try to open
if (out.good()) return true; // found it!
out.clear(); // Forget ye not
} while (base_to_uppercase(name, ++uppercasecount));
// file not found.
return false;
}
void OpenFile()
{
//std::cout << "LogManager try to open file to " << sLogFileName << std::endl;
if (logFile.is_open())
{
logFile << "Change to log file: "<< sLogFileName<< std::endl;
TimeTag();
EndFile();
logFile.close();
}
//First attempt to create the log file.
std::ostringstream filename;
filename << "results/logs/" << theApp->getStartTimeString() << "-eventLog";
if (mSide == RED) {
filename << "Red";
} else if (mSide == BLUE) {
filename << "Blue";
}
filename << ".txt";
logFile.open(filename.str().c_str());
//logFile.open(sLogFileName);
if (!logFile.is_open())
{
std::cout << "could not open file \""<<filename.str()<<"\"" << std::endl;
return;
}
else
{
//std::cout << "Using file \"delta3d_log.html\" for logging" << std::endl;
}
//TimeTag();
//logFile << std::endl;
logFile.flush();
//std::cout.flush();
}
int main(int argc, char *argv[])
{
// Initialize pin & symbol manager
PIN_InitSymbols();
if( PIN_Init(argc,argv) )
{
return Usage();
}
// Write to a file since cout and cerr maybe closed by the application
TraceFile.open(KnobOutputFile.Value().c_str());
TraceFile << hex;
TraceFile.setf(ios::showbase);
// Register Image to be called to instrument functions.
IMG_AddInstrumentFunction(Image, 0);
PIN_AddFiniFunction(Fini, 0);
// Never returns
PIN_StartProgram();
return 0;
}
/* =====================================================================
* Entry point for the tool
* ===================================================================== */
int main(int argc, char * argv[])
{
if (PIN_Init(argc, argv))
{
return Usage();
}
PIN_InitSymbols();
PIN_SemaphoreInit(&SemAllThreadStarted);
PIN_MutexInit(&MtxVecThreadIds);
PIN_MutexInit(&MtxActiveThread);
Out.open(KnobOutputFile.Value().c_str());
ASSERT(Out, "Failed to open file " + KnobOutputFile.Value());
IMG_AddInstrumentFunction(Image, 0);
PIN_AddFiniFunction(OnExit, 0);
// Never returns
PIN_StartProgram();
return 0;
}
int main(int argc, char *argv[])
{
if (PIN_Init(argc, argv))
return usage();
outfile.open("arqsimucache.out");
INS_AddInstrumentFunction(instrument_instruction, 0);
PIN_AddFiniFunction(finalize, 0);
RAM *ram = new RAM();
Cache *l2 = new Cache("L2", ram, 1000*1024, 2, 16);
Cache *l1 = new Cache("L1", l2, 64*1024, 2, 16);
front_memory = l1;
// start program and never return
PIN_StartProgram();
return 0;
}
void open_store(std::string outfile) {
owl_file.open(outfile.c_str(), std::ios::out);
// Write Prefix
if (owl_file.is_open()) {
for (std::map<std::string, std::string>::iterator it =
prefixes.begin(), ie = prefixes.end(); it != ie; ++it) {
owl_file << "Prefix(" << it->first << "=" << ANGLEQUOTE(it->second)
<< ")\n";
}
owl_file << "\n";
// Write Ontology
owl_file << "Ontology(" << ANGLEQUOTE(ontologyName) << "\n";
// Write Import
if (!importOWLs.empty()) {
for (std::vector<std::string>::iterator it = importOWLs.begin(),
ie = importOWLs.end(); it != ie; ++it) {
owl_file << "Import(" << ANGLEQUOTE(*it) << ")\n";
}
}
owl_file << "\n";
}
}
int main ()
{
//int posFlag = 0,velFlag = 0; // indicator to keep track of analysis function calls
while (std::getline(positionfile, line)) // Reading line by line
{
std::istringstream iss(line); // http://www.cplusplus.com/reference/sstream/istringstream/istringstream/
iss >> marker;
if ( marker == '$') {
//posFlag = 0;
//cout << "Read a special character $" << endl;
iss >> step >> filenum; // In position.txt file line beginning with $, ($ 1 1) = ($ step filenum)
cout << step << "\t" << filenum << endl;
filename = "postxtfiles/" + filenum + filetype; //postxtfiles is the directory in which i want to save it
//postxtfiles dir should exist in the current directory in which the program is running
cout << filename << endl;
PosFile.open(filename.c_str(), std::ofstream::out);
//PosFile << line << endl;
//cout << line << endl;
}
else if (marker == '#') {
wesnoth_global_fixture()
{
using namespace boost::unit_test;
reporter.open("boost_test_result.xml");
assert( reporter.is_open() );
results_reporter::set_stream(reporter);
// lg::set_log_domain_severity("all",lg::debug());
game_config::path = filesystem::get_cwd();
// Initialize unit tests
SDL_Init(SDL_INIT_TIMER);
test_utils::get_fake_display(1024, 768);
gui2::init();
static const gui2::event::manager gui_event_manager;
// Set more report as default
#if BOOST_VERSION >= 106000
if(runtime_config::get<log_level>(runtime_config::LOG_LEVEL) == invalid_log_level)
unit_test_log.set_threshold_level(log_messages);
if(runtime_config::get<report_level>(runtime_config::REPORT_LEVEL) == INV_REPORT_LEVEL)
results_reporter::set_level(SHORT_REPORT);
unit_test_monitor.register_exception_translator<game::error>(&exception_translator_game);
unit_test_monitor.register_exception_translator<config::error>(&exception_translator_config);
#else
if(runtime_config::log_level() == invalid_log_level)
unit_test_log.set_threshold_level(log_messages);
if(runtime_config::report_level() == INV_REPORT_LEVEL)
results_reporter::set_level(SHORT_REPORT);
unit_test_monitor.register_exception_translator<game::error>(&exception_translator_game);
unit_test_monitor.register_exception_translator<config::error>(&exception_translator_config);
#endif
}
// prints out the EMessageType , Class string , Method string , file path string , line string , current date string , and a message and apps to an file called Debuglog.txt
void Debug::Log(const EMessageType MsgType, const std::string& Class, const std::string& Method, const std::string& file, const int& line, const std::string& message) {
//clock objs
std::chrono::system_clock::time_point currenttime;
// initialize time_point
currenttime = std::chrono::system_clock::now();
//convert the currenttime obj into a time_t obj
static time_t debugTime = Debug::getCurrentTime(currenttime);
// file stream obj
static std::ofstream debugLog;
// open the stream obj
debugLog.open("debugLog.txt", std::ofstream::app | std::ofstream::out);
//switch statement using what type of message i should be getting
switch (MsgType) {
// for info print out the Class , Method of class , file path , which line the log was called , current time and date and a message regarding what could or is possibly happening
case EMessageType::INFO:
debugLog << "INFO: " << Class << "::" << Method << "() - " << "\n File :: " << file << "\n Line :: " << line << "\n Date :: " << ctime(&debugTime) << " Message :: " << message << "\n\n";
// break for next case
break;
// for warning print out the Class , Method of class , file path , which line the log was called , current time and date and a message regarding what could or is possibly happening
case EMessageType::WARNING:
debugLog << "WARNING: " << Class << "::" << Method << "() - " << "File :: " << file << ", Line :: " << line << ", Date :: " << ctime(&debugTime) << " Message :: " << message << "\n\n";
// break for next statement
break;
// for Error print out the Class , Method of class , file path , which line the log was called , current time and date and a message regarding what could or is possibly happening
case EMessageType::ERROR:
debugLog << "ERROR: " << Class << "::" << Method << "() - " << "File :: " << file << ", Line :: " << line << ", Date :: " << ctime(&debugTime) << " Message :: " << message << "\n\n";
// break for next statement
break;
// for FATAL_ERROR print out the Class , Method of class , file path , which line the log was called , current time and date and a message regarding what could or is possibly happening
case EMessageType::FATAL_ERROR:
debugLog << "FATAL ERROR: " << Class << "::" << Method << "() - " << "File :: " << file << ", Line :: " << line << ", Date :: " << ctime(&debugTime) << " Message :: " << message << "\n\n";
//final break
break;
}
//close the file
debugLog.close();
}
int main()
{
logfile.open("ai++.log", std::ios_base::out | std::ios_base::trunc);
if (!logfile.is_open()) {
std::cerr << "ai: cannot open log. terminating." << std::endl;
return 1;
}
RawBoard board;
uint8_t state;
AI ai;
while (true) {
read_board(std::cin, board);
read_state(std::cin, state);
AnalyzeResult result = ai.actuate(board);
if (std::get<1>(result)) {
std::cout << (uint8_t)std::get<0>(result) << std::flush;
} else {
std::cerr << "ai: no further options. terminating." << std::endl;
return 0;
}
}
}
int main(INT32 argc, CHAR **argv)
{
PIN_InitSymbols();
PIN_Init(argc, argv);
outfile.open("i18n_tool.out");
IMG img = IMG_Open(KnobUnicodeExeName.Value());
if (IMG_Valid(img) == TRUE)
{
string exeFullName = KnobUnicodeExeName.Value();
outfile << exeFullName.substr(exeFullName.rfind("/")+1) << endl;
IMG_Close(img);
}
IMG_AddInstrumentFunction(ImageLoad, 0);
PIN_AddFiniFunction(Fini, 0);
// Never returns
PIN_StartProgram();
return 0;
}
int parse_args(int argc, char **argv)
{
int option;
while ((option = getopt(argc, argv,"l:")) != -1)
{
switch (option) {
case 'l' :
if(logger)
logger.close();
logger.open(optarg, std::ofstream::out | std::ofstream::app);
if (logger.fail()) {
cerr << "open failure as expected: " << strerror(errno) << '\n';
return -1;
}
break;
default :
usage();
return -1;
}
}
}
void InitObjFile()
{
if (g_obj.is_open())
{
return;
}
std::ofstream file;
file.open("logger.obj");
if (file.is_open())
{
file.close();
}
g_obj.open("logger.obj", std::ios::app);
g_obj.setf(std::ios::fixed, std::ios::floatfield);
g_objFrameIndex = 0;
g_objObjectIndex = 0;
g_objVertexBaseIndex = 1;
g_objVertexIndex = 1;
}
int main(int argc, char *argv[])
{
if(argc==2){
double d = atof(argv[1]);
if(d!=0) amp = d;
else amp = 1000.0;
}
#ifdef FILE_SAVE
ptime now = second_clock::local_time();
std::string logname = to_iso_string(now) + std::string(".csv");
ofs.open(logname.c_str());
#endif /* FILE_SAVE */
port.set_option(serial_port_base::baud_rate(57600));
port.set_option(serial_port_base::character_size(8));
port.set_option(serial_port_base::flow_control(serial_port_base::flow_control::none));
port.set_option(serial_port_base::parity(serial_port_base::parity::none));
port.set_option(serial_port_base::stop_bits(serial_port_base::stop_bits::one));
boost::thread thr_io(boost::bind(&io_service::run, &io));
port.async_read_some( buffer(rbuf), boost::bind(&read_callback, _1, _2 ));
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_ALPHA);
glutInitWindowSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);
glutInitWindowPosition(0, 0);
window = glutCreateWindow("Value window");
glutDisplayFunc(&DrawGLScene);
glutIdleFunc(&DrawGLScene);
glutReshapeFunc(&ReSizeGLScene);
glutKeyboardFunc(&NormalKeyPressed);
glutSpecialFunc(&SpecialKeyPressed);
InitGL(DEFAULT_WIDTH, DEFAULT_HEIGHT);
glutMainLoop();
return 0;
}
void CommSerial::OpenFileAndPrintHeader(std::ofstream& out, const Grid& grid, const char* information)
{
char path_str[129];
int count = OutputCount();
sprintf(path_str, "%s%04d.dat", OutputPath().c_str(), count);
out.open(path_str, std::ios::trunc);
out << "# vtk DataFile Version 2.0" << std::endl
<< count << ": " << information << std::endl
<< "ASCII" << std::endl
<< "DATASET STRUCTURED_POINTS" << std::endl
<< grid.Local().Size().X() << " "
<< grid.Local().Size().Y() << " "
<< grid.Local().Size().Z() << std::endl
<< "ORIGIN 0 0 0" << std::endl
<< "SPACING " << grid.Extent().MeshWidth().X() << " "
<< grid.Extent().MeshWidth() << " "
<< grid.Extent().MeshWidth() << std::endl
<< "POINT_DATA " << grid.Local().Size().Product() << std::endl
<< "SCALARS residual double 1" << std::endl
<< "LOOKUP_TABLE default" << std::endl;
}
void PerfdataWriter::RotateFile(std::ofstream& output, const String& temp_path, const String& perfdata_path)
{
ObjectLock olock(this);
if (output.good()) {
output.close();
if (Utility::PathExists(temp_path)) {
String finalFile = perfdata_path + "." + Convert::ToString((long)Utility::GetTime());
if (rename(temp_path.CStr(), finalFile.CStr()) < 0) {
BOOST_THROW_EXCEPTION(posix_error()
<< boost::errinfo_api_function("rename")
<< boost::errinfo_errno(errno)
<< boost::errinfo_file_name(temp_path));
}
}
}
output.open(temp_path.CStr());
if (!output.good())
Log(LogWarning, "PerfdataWriter")
<< "Could not open perfdata file '" << temp_path << "' for writing. Perfdata will be lost.";
}
//TODO: Handle cleanup when killed close servos and serial
int main(int argc, const char* argv[])
{
try
{
if (argc != 3)
{
std::cerr << "Usage: <port> <base/lift>" << std::endl;
return 1;
}
boost::asio::io_service io_service;
int port = std::atoi(argv[1]);
const char* component = argv[2];
if(strcmp(component, "lift") == 0) {
const char* s = "/dev/servoblaster";
const char* d = "/dev/ttyAMA0";
servos.open(s, std::ofstream::out | std::ofstream::trunc);
lift_serial = serial_connection::create(io_service, d);
} else {
const char* d0 = "/dev/ttyAMA0";
//const char* d1 = "/dev/ttyUSB0";
base_serial = serial_connection::create(io_service, d0);
//sens_serial = serial_connection::create(io_service, d1);
}
std::cout << "Serving on port " << port << std::endl;
std::cout << "Controlling " << component << std::endl;
server s(io_service, port);
io_service.run();
}
catch (std::exception& e)
{
std::cerr << "Exception: " << e.what() << "\n";
}
return 0;
}
//opens the specified file
inline void open(const std::string &filename)
{
#ifdef DEBUG
file.open(filename.c_str());
#endif
}
CSV(const char *filename) {
out.open(filename);
}
//---------------------------------------------------------------------------------------
// ****************METODOS PARA TRABAJAR CON ARCHIVOS TEXTO DE SALIDA********************
//---------------------------------------------------------------------------------------
// Permite abrir un archivo de salida
bool VGeneral :: AbrirArchivoSalida (std::ofstream &archivo, char nomb_arch [128])
{
archivo.open (nomb_arch, ios::out);
return archivo.is_open();
}
int WINAPI
WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
{
// Parse the command line.
LPSTR cmd_line_including_exe_name = GetCommandLineA();
const int MAX_ARGS = 100;
int argc = 0;
char* argv[MAX_ARGS]; /* Flawfinder: ignore */
#if _DEBUG
logfile.open("updater.log", std::ios_base::out);
DEBUG("Parsing command arguments");
#endif
char *token = NULL;
if( cmd_line_including_exe_name[0] == '\"' )
{
// Exe name is enclosed in quotes
token = strtok( cmd_line_including_exe_name, "\"" );
argv[argc++] = token;
token = strtok( NULL, " \t," );
}
else
{
// Exe name is not enclosed in quotes
token = strtok( cmd_line_including_exe_name, " \t," );
}
while( (token != NULL) && (argc < MAX_ARGS) )
{
argv[argc++] = token;
/* Get next token: */
if (*(token + strlen(token) + 1) == '\"') /* Flawfinder: ignore */
{
token = strtok( NULL, "\"");
}
else
{
token = strtok( NULL, " \t," );
}
}
gUpdateURL = NULL;
/////////////////////////////////////////
//
// Process command line arguments
//
DEBUG("Processing command arguments");
//
// Parse the command line arguments
//
int parse_args_result = parse_args(argc, argv);
WNDCLASSEX wndclassex = { 0 };
//DEVMODE dev_mode = { 0 };
const int WINDOW_WIDTH = 250;
const int WINDOW_HEIGHT = 100;
wsprintf(gProgress, L"Connecting...");
/* Init the WNDCLASSEX */
wndclassex.cbSize = sizeof(WNDCLASSEX);
wndclassex.style = CS_HREDRAW | CS_VREDRAW;
wndclassex.hInstance = hInstance;
wndclassex.lpfnWndProc = WinProc;
wndclassex.hbrBackground = (HBRUSH) GetStockObject(WHITE_BRUSH);
wndclassex.lpszClassName = win_class_name;
RegisterClassEx(&wndclassex);
// Get the size of the screen
//EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &dev_mode);
gWindow = CreateWindowEx(NULL, win_class_name,
L"Second Life Updater",
WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT,
CW_USEDEFAULT,
WINDOW_WIDTH,
WINDOW_HEIGHT,
NULL, NULL, hInstance, NULL);
ShowWindow(gWindow, nShowCmd);
UpdateWindow(gWindow);
if (parse_args_result)
{
MessageBox(gWindow,
L"Usage: updater -url <url> [-name <window_title>] [-program <program_name>] [-silent]",
L"Usage", MB_OK);
return parse_args_result;
}
// Did we get a userserver to work with?
if (!gUpdateURL)
{
MessageBox(gWindow, L"Please specify the download url from the command line",
L"Error", MB_OK);
return 1;
}
// Can't feed GetTempPath into GetTempFile directly
char temp_path[MAX_PATH]; /* Flawfinder: ignore */
if (0 == GetTempPathA(sizeof(temp_path), temp_path))
{
MessageBox(gWindow, L"Problem with GetTempPath()",
L"Error", MB_OK);
return 1;
}
std::string update_exec_path(temp_path);
update_exec_path.append("Second_Life_Updater.exe");
WCHAR update_uri[4096];
mbstowcs(update_uri, gUpdateURL, sizeof(update_uri));
int success = 0;
int cancelled = 0;
// Actually do the download
try
{
DEBUG("Calling get_url_into_file");
success = get_url_into_file(update_uri, update_exec_path, &cancelled);
}
catch (const Fetcher::InetError& e)
{
(void)e;
success = FALSE;
DEBUG("Caught: " << e.what());
}
// WinInet can't tell us if we got a 404 or not. Therefor, we check
// for the size of the downloaded file, and assume that our installer
// will always be greater than 1MB.
if (gTotalBytesRead < (1024 * 1024) && ! cancelled)
{
MessageBox(gWindow,
L"The Second Life auto-update has failed.\n"
L"The problem may be caused by other software installed \n"
L"on your computer, such as a firewall.\n"
L"Please visit http://secondlife.com/download/ \n"
L"to download the latest version of Second Life.\n",
NULL, MB_OK);
return 1;
}
if (cancelled)
{
// silently exit
return 0;
}
if (!success)
{
MessageBox(gWindow,
L"Second Life download failed.\n"
L"Please try again later.",
NULL, MB_OK);
return 1;
}
// TODO: Make updates silent (with /S to NSIS)
//char params[256]; /* Flawfinder: ignore */
//sprintf(params, "/S"); /* Flawfinder: ignore */
//MessageBox(gWindow,
// L"Updating Second Life.\n\nSecond Life will automatically start once the update is complete. This may take a minute...",
// L"Download Complete",
// MB_OK);
/*==========================================================================*|
// DEV-31680: ShellExecuteA() causes McAfee-GW-Edition and AntiVir
// scanners to flag this executable as a probable virus vector.
// Less than or equal to 32 means failure
if (32 >= (int) ShellExecuteA(gWindow, "open", update_exec_path.c_str(), NULL,
"C:\\", SW_SHOWDEFAULT))
|*==========================================================================*/
// from http://msdn.microsoft.com/en-us/library/ms682512(VS.85).aspx
STARTUPINFOA si;
PROCESS_INFORMATION pi;
ZeroMemory(&si, sizeof(si));
si.cb = sizeof(si);
ZeroMemory(&pi, sizeof(pi));
if (! CreateProcessA(update_exec_path.c_str(), // executable file
NULL, // command line
NULL, // process cannot be inherited
NULL, // thread cannot be inherited
FALSE, // do not inherit existing handles
0, // process creation flags
NULL, // inherit parent's environment
NULL, // inherit parent's current dir
&si, // STARTUPINFO
&pi)) // PROCESS_INFORMATION
{
MessageBox(gWindow, L"Update failed. Please try again later.", NULL, MB_OK);
return 1;
}
// Give installer some time to open a window
Sleep(1000);
return 0;
}
int main(int argc,char *argv[])
{
typedef PsimagLite::Concurrency ConcurrencyType;
ConcurrencyType concurrency(&argc,&argv,1);
InputCheck inputCheck;
PsimagLite::String filename="";
int opt = 0;
OperatorOptions options;
PsimagLite::String strUsage(argv[0]);
if (utils::basename(strUsage) == "operator") options.enabled = true;
strUsage += " -f filename [-k] [-p precision] [-V] [whatToMeasure]";
int precision = 6;
bool keepFiles = false;
bool versionOnly = false;
/* PSIDOC DmrgDriver
\begin{itemize}
\item[-f] {[}Mandatory, String{]} Input to use.
\item[-p] [Optional, Integer] Digits of precision for printing.
\item[whatToMeasure] {[}Optional, String{]} What to measure in-situ
\item[-l] {[}Optional, String{]} Without this option std::cout is redirected
to a file.
This option with the string ``?'' prints name of such log file.
This option with the string ``-'' writes std::cout to terminal.
In other cases, string is the name of the file to redirect std::cout to.
\item[-k] [Optional] Keep untar files
\end{itemize}
*/
/* PSIDOC OperatorDriver
The arguments to the \verb!operator! executable are as follows.
\begin{itemize}
\item[-f] [Mandatory, String] Input to use. The Model= line is
very important in input.inp.
\item[-s] [Optional, Integer] Site for operator.
Meaningful only for Models where
the Hilbert space depends on the site (different kinds of atoms).
Defaults to 0.
\item[-l] [Mandatory, String] The label or name for this operator.
This is model dependent. For example to obtain $c_{\uparrow}$ for
the Hubbard model, say \begin{verbatim}
./operator -l c -f input.inp\end{verbatim}
See the function naturalOperator for each Model.
\item[-d] [Optional, Integer] Degree of freedom (spin, orbital or
combination of both) to use. This is model dependent. For example to
obtain $c_\downarrow$ for the Hubbard model, say
\begin{verbatim}./operator -l c -d 1 -f input.inp\end{verbatim}
See the function naturalOperator for each Model. Defaults to 0.
\item[-t] [Optional, Void] Transpose the operator. For example to
obtain $c^\dagger_\uparrow$ for a Hubbard model, say
\begin{verbatim}./operator -l c -t -f input.inp\end{verbatim}
\end{itemize}
*/
while ((opt = getopt(argc, argv,"f:s:l:d:F:o:p:tkV")) != -1) {
switch (opt) {
case 'f':
filename = optarg;
break;
case 'o':
std::cerr<<argv[0]<<": Omit the \"-o\". It's not needed anymore.\n";
std::cerr<<"\t Write the insitu measurements at the end of the command line\n";
return 1;
case 's':
options.site = atoi(optarg);
break;
case 'l':
options.label = optarg;
break;
case 'd':
options.dof = atoi(optarg);
break;
case 't':
options.transpose = true;
break;
case 'k':
keepFiles = true;
break;
case 'F':
std::cerr<<argv[0]<<": Omit the \"-F\". It's not needed anymore.\n";
std::cerr<<"\t It is implied by the label: n=bosonic, c=fermionic, etc\n";
return 2;
case 'p':
precision = atoi(optarg);
std::cout.precision(precision);
std::cerr.precision(precision);
break;
case 'V':
versionOnly = true;
options.label = "-";
break;
default:
inputCheck.usageMain(strUsage);
return 1;
}
}
// sanity checks here
if (filename=="" && !versionOnly) {
inputCheck.usageMain(strUsage);
return 1;
}
PsimagLite::String insitu = (optind < argc) ? argv[optind] : "";
if (!options.enabled && options.label != "-") {
bool queryOnly = (options.label == "?");
if (options.label == "" || options.label == "?") {
options.label = ArchiveFilesType::coutName(filename);
if (queryOnly) {
std::cout<<options.label<<"\n";
return 0;
}
}
GlobalCoutStream.open(options.label.c_str());
if (!GlobalCoutStream || GlobalCoutStream.bad()
|| !GlobalCoutStream.good()) {
PsimagLite::String str(argv[0]);
str += ": Could not redirect std::cout to " + options.label + "\n";
throw PsimagLite::RuntimeError(str);
}
std::cerr<<argv[0]<<" ATTENTION: All standard output now sent to ";
std::cerr<<options.label<<"\n";
std::cerr.flush();
GlobalCoutBuffer = std::cout.rdbuf(); //save old buf
std::cout.rdbuf(GlobalCoutStream.rdbuf()); //redirect std::cout to file
atexit(restoreCoutBuffer);
}
// print license
if (ConcurrencyType::root() && !options.enabled) {
std::cout<<ProgramGlobals::license;
Provenance provenance;
std::cout<<provenance;
}
if (versionOnly) return 0;
InputNgType::Writeable ioWriteable(filename,inputCheck);
InputNgType::Readable io(ioWriteable);
ParametersDmrgSolverType dmrgSolverParams(io, false);
ArchiveFilesType af(dmrgSolverParams,filename,options.enabled,options.label);
if (insitu!="") dmrgSolverParams.insitu = insitu;
if (dmrgSolverParams.options.find("minimizeDisk") != PsimagLite::String::npos)
dmrgSolverParams.options += ",noSaveWft,noSaveStacks,noSaveData";
#ifndef USE_PTHREADS
inputCheck.checkForThreads(dmrgSolverParams.nthreads);
#endif
ConcurrencyType::npthreads = dmrgSolverParams.nthreads;
registerSignals();
PsimagLite::String targeting = inputCheck.getTargeting(dmrgSolverParams.options);
bool isComplex = (dmrgSolverParams.options.find("useComplex") != PsimagLite::String::npos);
if (targeting=="TimeStepTargetting") isComplex = true;
if (isComplex) {
mainLoop0<MySparseMatrixComplex, CvectorSizeType>(io,dmrgSolverParams,targeting,options);
} else {
mainLoop0<MySparseMatrixReal, CvectorSizeType>(io,dmrgSolverParams,targeting,options);
}
if (options.enabled) return 0;
af.deletePackedFiles();
if (!keepFiles)
ArchiveFilesType::staticDelete();
}
void DebugFile::init(std::string filename)
{
file.open(filename.c_str(), std::ios::out | std::ios::app );
file << "\n\n-----------------------------------------\n";
currentTime() << " : Starting log.";
}
/*
* Tool used for verifying that libdft propagates taint correctly.
*/
int main(int argc, char **argv) {
/* initialize symbol processing */
PIN_InitSymbols();
if (unlikely(PIN_Init(argc, argv)))
goto err;
IMG_AddInstrumentFunction(ImageLoad, 0);
PIN_AddFiniFunction(OnExit, 0);
#ifdef DTRACKER_DEBUG
INS_AddInstrumentFunction(CheckMagicValue, 0);
#endif
LOG("Initializing libdft.\n");
if (unlikely(libdft_init() != 0))
goto err;
// reset counters
bzero(stdcount, sizeof(stdcount));
// Open raw prov file.
// This file is to be post-processed to get the data in a proper format.
rawProvStream.open(ProvRawKnob.Value().c_str());
/*
* Install taint sources and sinks.
* syscall_set_{pre, post}() set the callbacks in the libdft
* syscall description struct.
* These callbacks are respectively invoked through
* sysenter_save() and sysexit_save() function of libdft.
* In turn, these libdft functions are hooked to run before/after
* every syscall using PIN_AddSyscall{Entry, Exit}Function().
*/
/* dtracker_openclose.cpp: open(2), creat(2), close(2) */
(void)syscall_set_pre(&syscall_desc[__NR_open], pre_open_hook);
(void)syscall_set_pre(&syscall_desc[__NR_creat], pre_open_hook);
(void)syscall_set_post(&syscall_desc[__NR_open], post_open_hook);
(void)syscall_set_post(&syscall_desc[__NR_creat], post_open_hook);
(void)syscall_set_post(&syscall_desc[__NR_close], post_close_hook);
/* dtracker_read.cpp: read(2), readv(2) */
(void)syscall_set_post(&syscall_desc[__NR_read], post_read_hook);
(void)syscall_set_post(&syscall_desc[__NR_readv], post_readv_hook);
/* dtracker_write.cpp: write(2), writev(2) */
(void)syscall_set_post(&syscall_desc[__NR_write], post_write_hook);
(void)syscall_set_post(&syscall_desc[__NR_writev], post_writev_hook);
/* dtracker_mmap.cpp: mmap2(2), munmap(2) */
(void)syscall_set_post(&syscall_desc[__NR_mmap2], post_mmap2_hook);
(void)syscall_set_post(&syscall_desc[__NR_munmap], post_munmap_hook);
/* start the program and return something to make the compiler happy */
LOG("Starting program.\n");
PIN_StartProgram();
return EXIT_SUCCESS;
err:
/* error handling */
/* detach from the process */
libdft_die();
/* return */
return EXIT_FAILURE;
}
int main(int argc, char** argv)
{
GameLog::Initialize();
lout.open("log.txt",ios::out);
stateMainMenu = true;
stateGameMenu = false;
bool kbEscape = false;
global_config.Load();
Assets::SetMusicVolume(global_config.music_volume);
Assets::SetSoundVolume(global_config.sound_volume);
if(global_config.music == false)Assets::SetMusicVolume(0);
if(global_config.sound == false)Assets::SetSoundVolume(0);
Engine* engine;
engine = new Engine(global_config.width,global_config.height,global_config.fullscreen);
sf::Image ico_darkhold;
ico_darkhold.loadFromFile("./icon.png");
engine->GetRenderContext().setIcon(128,128,ico_darkhold.getPixelsPtr());
engine->GetRenderContext().setMouseCursorVisible(false);
engine->GetRenderContext().setFramerateLimit(60);
Assets::LoadPack(global_config.pack_assets);
Assets::LoadList(global_config.list_assets);
font_game = new Sprite("font_game",96);
bool gamestarted = false;
Assets::svolume = global_config.sound_volume;
Assets::mvolume = global_config.music_volume;
Assets::music = global_config.music;
Assets::sound = global_config.sound;
cout <<"[SYSTEM] Game started." << endl;
engine->ff_phase = 1;
engine->ff_alpha = 1.0F;
screen_list.push_back(new ScreenMainMenu());
while(engine->IsRunning())
{
glClearColor(0.0F,0.0F,0.0F,1.0F);
engine->Update();
glDisable(GL_DEPTH_TEST);
Assets::svolume = global_config.sound_volume;
Assets::mvolume = global_config.music_volume;
Assets::music = global_config.music;
Assets::sound = global_config.sound;
if(gamestarted == false)
{
// Draw the title screen
if(engine->ff_phase != 0)engine->Fade();
Sprite* font_display = new Sprite("font_display",97);
engine->SetFont(font_game);
Engine::Print(0,0,"DARKHOLD DEMO",1.0F,0.0F,0.0F);
font_display->w = 7;
engine->SetFont(font_game);
Engine::Print(0,40,"THIS IS A WORKING AND FULLY PLAYABLE");
Engine::Print(0,50,"'EPISODE' OF MY GAME.");
Engine::Print(0,60,"IT CONTAINS FOUR LEVELS AND A BOSS");
Engine::Print(0,70,"ARENA, SEVERAL RUNES, MULTIPLE ENEMIES AND");
Engine::Print(0,80,"IN ALL LIKELIHOOD, A FAIR SHARE OF BUGS.");
Engine::Print(0,90,"ENJOY THE GAME; I MAY KEEP WORKING ON");
Engine::Print(0,100,"IT IF PEOPLE LIKE THE CONCEPT.");
Engine::Print(0,120,"PRESS SPACE OR (X) TO CONTINUE...",0.3F,0.3F,0.9F);
engine->Render();
delete font_display;
if(sf::Keyboard::isKeyPressed(sf::Keyboard::Space) || sf::Joystick::isButtonPressed(0,0))
{
gamestarted = true;
}
if(sf::Keyboard::isKeyPressed(sf::Keyboard::Escape))
{
engine->GetRenderContext().close();
}
continue;
}
if(screen_list.empty() != true)
{
screen_list.back()->update();
if(screen_list.back()->isDone())
{
screen_list.pop_back();
}
continue;
}
// Check if Escape is pressed
if(sf::Keyboard::isKeyPressed(sf::Keyboard::Escape) || sf::Joystick::isButtonPressed(0,7))
{
if(!kbEscape)
{
screen_list.push_back(new ScreenGameMenu());
}
kbEscape = true;
}
else kbEscape = false;
engine->go3D();
glEnable(GL_ALPHA_TEST);
glAlphaFunc(GL_GREATER,0);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
// Render stuff in 3D here
engine->go2D();
glDisable(GL_LIGHTING);
// Render 2D stuff here
engine->Render();
}
delete engine;
delete font_game;\
Assets::Destroy();
global_config.Write();
lout.flush();
lout.close();
return 0;
}
int main() {
double pi2 = pi * pi;
double at,dt1,Idc0,Idcn,dIdc,Idc,w1,I1,f0,T1,tn,t0,h,t,b,q0,q10,f1,L,r,a1,a2,a3,a4,b1,b2,b3,b4,c1,c2,c3,c4,V,Vs,q1s,P,Psc,q1sc,dVs,dq1s,dPsc,dq1sc,Ijj,w0;
double f,q,q1;
int n;
cout << "Idc0=";
cin >> Idc0;
cout << "Idcn=";
cin >> Idcn;
cout << "dI=";
cin >> dIdc;
cout << "w1=";
cin >> w1;
cout << "I1=";
cin >> I1;
cout << "f0=";
cin >> f0;
cout << "n=";
cin >> n;
cout << "w0=";
cin >> w0;
cout << "b=";
cin >> b;
cout << "r=";
cin >> r;
cout << "dt=";
cin >> h;
cout << "dt1=";
cin >> dt1;
cout << "at=";
cin >> at;
res.open("absorpsingleres.txt", std::ios_base::app);
L=1/(b*w0*w0);
Idc=Idc0;
t0=0;
T1=2*pi/w1;
tn=at+n*T1;
while(Idc<=Idcn) {
cout << "Idc=" << Idc << ", l=" << l << "\n";
t=t0;
q=0;
f=f0;
q1=0;
Vs=0;
q1s=0;
Psc=0;
q1sc=0;
while(t<=at) {
f1=f;
q10=q1;
a1=phi1(q1);
b1=phi2(Idc,I1,w1,t,f,q1);
c1=phi3(L,w0,r,Idc,I1,w1,t,q,f,q1);
a2=phi1(q1+dt1*c1/2);
b2=phi2(Idc,I1,w1,t+dt1/2,f+dt1*b1/2,q1+dt1*c1/2);
c2=phi3(L,w0,r,Idc,I1,w1,t+dt1/2,q+dt1*a1/2,f+dt1*b1/2,q1+dt1*c1/2);
a3=phi1(q1+dt1*c2/2);
b3=phi2(Idc,I1,w1,t+dt1/2,f+dt1*b2/2,q1+dt1*c2/2);
c3=phi3(L,w0,r,Idc,I1,w1,t+dt1/2,q+dt1*a2/2,f+dt1*b2/2,q1+dt1*c2/2);
a4=phi1(q1+dt1*c3);
b4=phi2(Idc,I1,w1,t+dt1,f+dt1*b3,q1+dt1*c3);
c4=phi3(L,w0,r,Idc,I1,w1,t+dt1,q+dt1*a3,f+dt1*b3,q1+dt1*c3);
q=q+dt1*(a1+2*a2+2*a3+a4)/6;
f=f+dt1*(b1+2*b2+2*b3+b4)/6;
q1=q1+dt1*(c1+2*c2+2*c3+c4)/6;
t=t+dt1;
if (f > pi2) {
f = f - pi2;
}
res << t << " " << q << " " << f << " " << q1 << "\n";
}
/*
while(t<=tn) {
f1=f;
q10=q1;
a1=phi1(q1);
b1=phi2(Idc,I1,w1,t,f,q1);
c1=phi3(L,w0,r,Idc,I1,w1,t,q,f,q1);
a2=phi1(q1+h*c1/2);
b2=phi2(Idc,I1,w1,t+h/2,f+h*b1/2,q1+h*c1/2);
c2=phi3(L,w0,r,Idc,I1,w1,t+h/2,q+h*a1/2,f+h*b1/2,q1+h*c1/2);
a3=phi1(q1+h*c2/2);
b3=phi2(Idc,I1,w1,t+h/2,f+h*b2/2,q1+h*c2/2);
c3=phi3(L,w0,r,Idc,I1,w1,t+h/2,q+h*a2/2,f+h*b2/2,q1+h*c2/2);
a4=phi1(q1+h*c3);
b4=phi2(Idc,I1,w1,t+h,f+h*b3,q1+h*c3);
c4=phi3(L,w0,r,Idc,I1,w1,t+h,q+h*a3,f+h*b3,q1+h*c3);
q=q+h*(a1+2*a2+2*a3+a4)/6;
f=f+h*(b1+2*b2+2*b3+b4)/6;
q1=q1+h*(c1+2*c2+2*c3+c4)/6;
t=t+h;
dVs=(sin(f1)+sin(f))*h/2;
Vs=Vs+dVs;
dq1s=(q10+q1)*h/2;
q1s=q1s+dq1s;
dPsc=(sin(f1)*cos(w1*(t-h))+sin(f)*cos(w1*t))*h/2;
Psc=Psc+dPsc;
dq1sc=(q10*cos(w1*(t-h))+q1*cos(w1*t))*h/2;
q1sc=q1sc+dq1sc;
}
V=Idc-Vs/(n*T1)-q1s/(n*T1);
P=I1/2-Psc/(n*T1)-q1sc/(n*T1);
Ijj=Idc-q1s/(n*T1);
//res << Idc << " " << Ijj << " " << V << " " << P << "\n";
*/
Idc=Idc+dIdc;
}
res.close();
return 0;
}
error() : logger2("Error") {
#ifdef CPP_LOG_ERR_FILE
ofs.open(CPP_LOG_ERR_FILE,
std::ios_base::app | std::ios_base::out);
#endif
};
int main(int argc, char* argv[])
{
std::vector<Mat<float> > mse;
//Neural Networks settings :
Topology topo;
unsigned int nbrneurons = 25;
unsigned int nbrlayer = 1;
unsigned int nbrinput = width*height;
unsigned int nbroutput = 10;
//topo.push_back(nbrinput,NTNONE); //input layer
topo.push_back(nbrinput,NTSIGMOID); //input layer
//topo.push_back(nbrneurons, NTSIGMOID);
topo.push_back(15, NTSIGMOID);
//topo.push_back(nbroutput, NTSOFTMAX); //linear output
topo.push_back(nbroutput, NTSIGMOID); //linear output
NN<float> nn(topo);
nn.learning = false;
//------------------------------
//DATASET SETTINGS :
report.open(report_fn.c_str(), ios::out);
image.open(training_image_fn.c_str(), ios::in | ios::binary); // Binary image file
label.open(training_label_fn.c_str(), ios::in | ios::binary ); // Binary label file
// Reading file headers
char number;
for (int i = 1; i <= 16; ++i) {
image.read(&number, sizeof(char));
}
for (int i = 1; i <= 8; ++i) {
label.read(&number, sizeof(char));
}
//------------------------------
//checking rotation :
Mat<float> im1(8,8, (char)1);
Mat<float> im2( rotate(im1,PI/2.0f) );
im1.afficher();
im2.afficher();
//--------------------------------
//checking arctan !!!
float y = -4.0f;
float x = 4.0f;
std::cout << arctan(y,x)*180.0f/(PI) << std::endl;
//--------------------------------------------------
//checking reading :
char labelval = 0;
float theta = PI/2;
im1 = inputMNIST(labelval);
im2 = rotate(im1,theta);
im2.afficher();
std::cout << "Rotation of : " << theta*180.0f/PI << std::endl;
//---------------------------------------------------
int iteration = 25000;
int offx = 2;
int offy = 2;
int size = 28;
int countSuccess = 0;
while( iteration)
{
Mat<float> rotatedinput( inputMNIST(labelval) );
//let us choose the rotation :
float theta = ((float)(rand()%360))*PI/180.0f;
//let us apply it :
rotatedinput = extract( rotate(rotatedinput, theta), offx,offy, offx+(size-1), offy+(size-1) );
Mat<float> input( reshapeV( rotatedinput ) );
Mat<float> target( 0.0f, 10,1);
target.set( 1.0f, labelval+1, 1);
if(labelval < 9)
{
Mat<float> output( nn.feedForward( input) );
int idmax = idmin( (-1.0f)*output).get(1,1);
transpose( operatorL(target,output) ).afficher();
std::cout << " LEARNING ITERATION : " << iteration << " ; IDMAX = " << idmax << std::endl;
nn.backProp(target);
//nn.backPropCrossEntropy(target);
//counting :
if(idmax == labelval+1)
{
countSuccess++;
}
//-------------------
if( iteration % 1000 == 0)
{
std::cout << " TEST : " << countSuccess << " / " << 1000 << std::endl;
mse.push_back(Mat<float>((float)countSuccess,1,1));
writeInFile(std::string("./mse.txt"), mse);
countSuccess = 0;
}
iteration--;
}
}
std::cout << " VALIDATION TEST : in progress.." << std::endl;
iteration = 1000;
int success = 0;
while( iteration)
{
Mat<float> rotatedinput( inputMNIST(labelval) );
//let us choose the rotation :
//float theta = rand()%360;
float theta = ((float)(rand()%360))*PI/180.0f;
//let us apply it :
rotatedinput = extract( rotate(rotatedinput, theta), offx,offy, offx+(size-1), offy+(size-1) );
Mat<float> input( reshapeV( rotatedinput ) );
Mat<float> target( 0.0f, 10,1);
target.set( 1.0f, labelval+1, 1);
if(labelval < 5)
{
Mat<float> output( nn.feedForward( input));
int idmax = idmin( (-1.0f)*output).get(1,1);
transpose(output).afficher();
std::cout << " ITERATION : " << iteration << " ; IDMAX = " << idmax << std::endl;
if(idmax == labelval+1)
{
success++;
}
iteration--;
}
}
std::cout << "VALIDATION TEST : " << success << " / 1000." << std::endl;
report.close();
label.close();
image.close();
nn.save(std::string("neuralnetworksDIGITROTATED"));
return 0;
}
warning() : logger2("Warning") {
#ifdef CPP_LOG_WARN_FILE
ofs.open(CPP_LOG_WARN_FILE,
std::ios_base::app | std::ios_base::out);
#endif
};