/// Save part of the data, given time-window
void TPgBlob::PartialFlush(int WndInMsec) {
if (Access == TFAccess::faRdOnly)
return;
TTmStopWatch sw(true);
for (int i = 0; i < LoadedPages.Len(); i++) {
if (ShouldSavePage(i)) {
LoadedPage& a = LoadedPages[i];
Files[a.Pt.GetFIx()]->SavePage(a.Pt.GetPg(), GetPageBf(i));
if (sw.GetMSec() > WndInMsec)
break;
}
}
}
int main()
{
// Construct the Gaussian map of a tetrahedron
Point_3 points[] = {
Point_3(1.0, 0.0, 0.0),
Point_3(0.0, 1.0, 0.0),
Point_3(0.0, 0.0, 1.0),
Point_3(0.0, 0.0, 0.0)
};
Gm_polyhedron P1;
CGAL::convex_hull_3(points, &points[4], P1);
Gm gm1;
Gm_initializer gm_initializer1(gm1);
gm_initializer1(P1);
if (! gm1.is_valid()) return -1;
// Construct the Gaussian map of the reflection of a tetrahedron
Gm_polyhedron P2;
for (Point_3* p = points; p != &points[4]; ++p) {
Kernel::Vector_3 v = CGAL::ORIGIN - *p;
*p = CGAL::ORIGIN + v;
}
CGAL::convex_hull_3(points, &points[4], P2);
Gm gm2;
Gm_initializer gm_initializer2(gm2);
gm_initializer2(P2);
if (! gm2.is_valid()) return -1;
// Compute the Minowski sum of the Gaussian maps
Gm gm;
gm.minkowski_sum(gm1, gm2);
if (! gm.is_valid()) return -1;
Kernel::FT sw(16);
Gm::Vertex_const_handle it;
for (it = gm.vertices_begin(); it != gm.vertices_end(); ++it) {
if (it->degree() < 3) continue;
Gm::Halfedge_around_vertex_const_circulator hec3(it->incident_halfedges());
Gm::Halfedge_around_vertex_const_circulator hec1 = hec3++;
Gm::Halfedge_around_vertex_const_circulator hec2 = hec3++;
Kernel::Plane_3 plane((*hec1).face()->point(), (*hec2).face()->point(),
(*hec3).face()->point());
Kernel::Vector_3 v(CGAL::ORIGIN, plane.projection(CGAL::ORIGIN));
Kernel::FT tmp = v.squared_length();
if (tmp < sw) sw = tmp;
}
// std::cout << sw << std::endl;
CGAL::Gmpq res(1,3);
if (sw.exact() != res) return -1;
return 0;
}
bool
O2DatDB::
select(O2DatRec &out)
{
#if TRACE_SQL_EXEC_TIME
stopwatch sw("select random 1");
#endif
bool ret = true;
sqlite3 *db = NULL;
int err = sqlite3_open16(dbfilename.c_str(), &db);
if (err != SQLITE_OK)
goto error;
sqlite3_busy_timeout(db, 5000);
wchar_t *sql =
L"select"
COLUMNS
L" from dat"
L" order by random() limit 1;";
sqlite3_stmt *stmt = NULL;
err = sqlite3_prepare16_v2(db, sql, wcslen(sql)*2, &stmt, NULL);
if (err != SQLITE_OK)
goto error;
sqlite3_reset(stmt);
err = sqlite3_step(stmt);
if (err != SQLITE_ROW && err != SQLITE_DONE)
goto error;
if (err == SQLITE_DONE)
ret = false;
if (err == SQLITE_ROW)
get_columns(stmt, out);
sqlite3_finalize(stmt);
stmt = NULL;
err = sqlite3_close(db);
if (err != SQLITE_OK)
goto error;
return (ret);
error:
log(db);
if (stmt) sqlite3_finalize(stmt);
if (db) sqlite3_close(db);
return false;
}
int main() {
utils::StopWatch sw(true);
std::stringstream ss;
ss << twosat();
std::cout << ss.str() << std::endl;
utils::CopyToClipboard(ss.str());
sw.stop();
std::cout << sw.getLastElapsed();
std::cin.ignore();
return 0;
}
uint64
O2DatDB::
select_datcount(wstrnummap &out)
{
#if TRACE_SQL_EXEC_TIME
stopwatch sw("select datcount group by domain bbsname");
#endif
sqlite3 *db = NULL;
sqlite3_stmt *stmt = NULL;
wstring domain_bbsname;
uint64 total = 0;
uint64 num;
int err = sqlite3_open16(dbfilename.c_str(), &db);
if (err != SQLITE_OK)
goto error;
sqlite3_busy_timeout(db, 5000);
wchar_t *sql =
L"select domain, bbsname, count(*) from dat group by domain, bbsname;";
err = sqlite3_prepare16_v2(db, sql, wcslen(sql)*2, &stmt, NULL);
if (err != SQLITE_OK)
goto error;
while (sqlite3_step(stmt) == SQLITE_ROW) {
domain_bbsname = (wchar_t*)sqlite3_column_text16(stmt, 0);
domain_bbsname += L":";
domain_bbsname += (wchar_t*)sqlite3_column_text16(stmt, 1);
num = sqlite3_column_int64(stmt, 2);
out.insert(wstrnummap::value_type(domain_bbsname, num));
total += num;
}
sqlite3_finalize(stmt);
stmt = NULL;
err = sqlite3_close(db);
if (err != SQLITE_OK)
goto error;
return (total);
error:
log(db);
if (stmt) sqlite3_finalize(stmt);
if (db) sqlite3_close(db);
return false;
}
static int generate_report_files(const TCHAR* a_short_name, struct _EXCEPTION_POINTERS* ep)
{
static const size_t char_count=1024;
muradin::dbg::Win32Path this_module_path=muradin::dbg::Win32Path::path_of_module(NULL);
TCHAR report_file[char_count]={0};
muradin::dbg::make_base_file_name(a_short_name,report_file,char_count);
muradin::dbg::Win32Path abs_path=this_module_path.new_file_path(report_file);
muradin::dbg::ModuleInfoFilePrinter moudel_report(abs_path.full_path(report_file),_T("a"));
muradin::dbg::CallstackFilePrinter callstack_report(abs_path.full_path(report_file),_T("a"));
DWORD process_id=::GetCurrentProcessId();
muradin::dbg::Win32Handle process(::OpenProcess( PROCESS_QUERY_INFORMATION |PROCESS_VM_READ,FALSE, process_id ));
//////////////////////////////////////////////////////////////////////////
/// generate module info for current process
muradin::dbg::ModuleFileEnumerator mod_em(boost::bind(&muradin::dbg::ModuleInfoFilePrinter::print,&moudel_report,_1,_2,_3));
moudel_report.open();
int sys_error=0;
bool good=mod_em.enum_proc_modules(process.get(),process_id,sys_error);
moudel_report.close();
//////////////////////////////////////////////////////////////////////////
/// output exception info
ExceptionPointerFormator epfmt;
callstack_report.open();
callstack_report.print(epfmt.fmt(ep));
callstack_report.close();
//////////////////////////////////////////////////////////////////////////
/// generate callstack
muradin::dbg::StackWalker sw(boost::bind(&muradin::dbg::CallstackFilePrinter::print,&callstack_report,_1,_2,_3),
::GetCurrentProcessId(),::GetCurrentProcess());
callstack_report.open();
sw.get_callstacks(GetCurrentThread(),ep->ContextRecord);
callstack_report.close();
//////////////////////////////////////////////////////////////////////////
/// put a message to say we miss dbghelp.dll
muradin::dbg::DbgHelperAPI dbghelpdll;
if(!dbghelpdll.load()){
callstack_report.open();
callstack_report.print_ln(_T("cant general full information for callstack,miss dbghelp.dll"));
callstack_report.close();
}
return 0;
}
void WPUtils::getBlogs(QString u, QString p, QString blog_address)
{
_xml.clear();
QXmlStreamWriter sw(&_xml);
sw.setAutoFormatting(true);
sw.writeStartDocument();
sw.writeStartElement("methodCall");
sw.writeTextElement("methodName", "wp.getUsersBlogs");
sw.writeStartElement("params");
sw.writeStartElement("param");
sw.writeCharacters("username");
sw.writeTextElement("value", u);
sw.writeEndElement();
sw.writeStartElement("param");
sw.writeCharacters("password");
sw.writeTextElement("value", p);
sw.writeEndElement();
sw.writeEndDocument();
QNetworkAccessManager *manager = new QNetworkAccessManager();
manager->setObjectName("getUsersBlogs");
QObject::connect(manager, SIGNAL(finished(QNetworkReply*)), this, SLOT(replyFinished(QNetworkReply*)));
QUrl url;
//_xml = xml.toUtf8();
QString tmp_url = searchEndPoint(blog_address);
if ( tmp_url.isEmpty() )
{
qDebug() << "unable to found endpoint";
res.insert("ERROR","ERROR");
} else {
url.setUrl(tmp_url);
QNetworkRequest request(url);
int cmd = 0;
request.setAttribute(QNetworkRequest::Attribute(QNetworkRequest::User + 1), QVariant((int) cmd)); /* not sure */
request.setRawHeader("User-Agent", "wp-bb10/0.0.1");
request.setHeader(QNetworkRequest::ContentTypeHeader, "text/xml");
manager->post(request,_xml);
}
}
int main()
{
bool start = false;
std::cout << "StopWatch Example" << std::endl;
techtips::StopWatch sw(start);
sw.start();
some_method();
sw.stop();
std::cout << "execute_some_method: took " << sw.elapsed() << " milisecods time to execute" << std::endl;
std::cout << "--------------------------------------------------------------------------------" << std::endl;
std::cout << "ScopedStopWatch Example" << std::endl;
some_method_scoped_stop_watch_example();
return 0;
}
/*
* Provide a series of lat/lon coordinates/waypoints, and the object
* automatically generates a bounding rectangle, and determines how to
* translate between lat/lon and cartesian x/y
*/
void Mapping::init(int count, GeoPosition *p)
{
double latMin = 360;
double latMax = -360;
double lonMin = 360;
double lonMax = -360;
// Find minimum and maximum lat/lon
for (int i=0; i < count; i++, p++) {
//fprintf(stdout, "%d (%.6f, %.6f)\n", i, p->latitude(), p->longitude());
if (p->latitude() > latMax)
latMax = p->latitude();
if (p->latitude() < latMin)
latMin = p->latitude();
if (p->longitude() > lonMax)
lonMax = p->longitude();
if (p->longitude() < lonMin)
lonMin = p->longitude();
}
// Set the arbitrary cartesian origin to southwest corner
lonZero = lonMin;
latZero = latMin;
//fprintf(stdout, "min: (%.6f, %.6f)\n", latMin, lonMin);
//fprintf(stdout, "max: (%.6f, %.6f)\n", latMax, lonMax);
// Three positions required to scale
GeoPosition sw(latMin, lonMin);
GeoPosition nw(latMax, lonMin);
GeoPosition se(latMin, lonMax);
// Find difference between lat and lon min/max
float dlat = (latMax - latMin);
float dlon = (lonMax - lonMin);
//fprintf(stdout, "dlat=%.6f dlon=%.6f\n", dlat, dlon);
// Compute scale based on distances between edges of rectangle
// and difference between min/max lat and min/max lon
lonToX = sw.distanceTo(se) / dlon;
latToY = sw.distanceTo(nw) / dlat;
//fprintf(stdout, "lonToX=%.10f\nlatToY=%.10f\n", lonToX, latToY);
return;
}
CSmartPtr<CSwitch> CSwitchMgr::getSwitchByMac(const INT1* mac)
{
CSmartPtr<CSwitch> sw(NULL);
if (NULL == mac)
return sw;
INT1 macStr[20] = {0};
mac2str((UINT1*)mac, macStr);
CMacHMap::CPair* item = NULL;
if (m_macMap.find(macStr, &item))
sw = item->second;
return sw;
}
void
testGetNumSamples()
{
SlidingWindow sw(0.25);
// simTime 0.0, insert [email protected]
sw.put(1.0);
WNS_ASSERT_MAX_REL_ERROR( 0, sw.getNumSamples(), 0 );
wns::simulator::getEventScheduler()->scheduleDelay(events::NoOp(), 0.1);
wns::simulator::getEventScheduler()->processOneEvent();
// simTime 0.1, 1 sample
WNS_ASSERT_MAX_REL_ERROR( 1, sw.getNumSamples(), 0 );
// insert [email protected]
sw.put(1.0);
WNS_ASSERT_MAX_REL_ERROR( 1, sw.getNumSamples(), 0 );
wns::simulator::getEventScheduler()->scheduleDelay(events::NoOp(), 0.1);
wns::simulator::getEventScheduler()->processOneEvent();
// simTime 0.2,
WNS_ASSERT_MAX_REL_ERROR( 2, sw.getNumSamples(), 0 );
// insert [email protected]
sw.put(1.0);
WNS_ASSERT_MAX_REL_ERROR( 2, sw.getNumSamples(), 0 );
wns::simulator::getEventScheduler()->scheduleDelay(events::NoOp(), 0.05);
wns::simulator::getEventScheduler()->processOneEvent();
// simTime 0.25
WNS_ASSERT_MAX_REL_ERROR( 3, sw.getNumSamples(), 0 );
wns::simulator::getEventScheduler()->scheduleDelay(events::NoOp(), 0.05);
wns::simulator::getEventScheduler()->processOneEvent();
// simTime 0.3
WNS_ASSERT_MAX_REL_ERROR( 2, sw.getNumSamples(), 0 );
wns::simulator::getEventScheduler()->scheduleDelay(events::NoOp(), 0.1);
wns::simulator::getEventScheduler()->processOneEvent();
// simTime 0.4
WNS_ASSERT_MAX_REL_ERROR( 1, sw.getNumSamples(), 0 );
wns::simulator::getEventScheduler()->scheduleDelay(events::NoOp(), 0.1);
wns::simulator::getEventScheduler()->processOneEvent();
// simTime 0.5
WNS_ASSERT_MAX_REL_ERROR( 0, sw.getNumSamples(), 0 );
}
int main(int argc, char const* argv[]) {
auto args = parse(argc, argv);
if (args.exit) {
return args.exit + 1;
}
Stopwatch sw("Program");
Codecs::HuffmanCodec huffman;
Codecs::FreqCodec freq(args.power);
Codecs::TrivialCodec triv;
Codecs::MultiCodec main_codec(2, &freq, &huffman);
StreamTester tester;
tester.set_codec(main_codec);
tester.set_data_file(args.file_name, args.read_block);
tester.learn_codec();
tester.test_all();
return 0;
}
int main() {
Simple_window win1{x,800,600,"Rectangle functions"};
Graph_lib::Rectangle r{Point {200,200},150,250};
Graph_lib::Marks m{"x"};
m.add(n(r));
m.add(w(r));
m.add(s(r));
m.add(e(r));
m.add(center(r));
m.add(nw(r));
m.add(ne(r));
m.add(sw(r));
m.add(se(r));
win1.attach(r);
win1.attach(m);
win1.wait_for_button();
}
uint64
O2DatDB::
select_publishcount(time_t publish_tt)
{
#if TRACE_SQL_EXEC_TIME
stopwatch sw("select datcount by lastpublish");
#endif
sqlite3 *db = NULL;
sqlite3_stmt *stmt = NULL;
int err = sqlite3_open16(dbfilename.c_str(), &db);
if (err != SQLITE_OK)
goto error;
sqlite3_busy_timeout(db, 5000);
wchar_t *sql = L"select count(*) from dat where lastpublish > ?;";
err = sqlite3_prepare16_v2(db, sql, wcslen(sql)*2, &stmt, NULL);
if (err != SQLITE_OK)
goto error;
if (!bind(db, stmt, 1, time(NULL)-publish_tt))
goto error;
err = sqlite3_step(stmt);
if (err != SQLITE_ROW && err != SQLITE_DONE)
goto error;
uint64 count = sqlite3_column_int64(stmt,0);
sqlite3_finalize(stmt);
stmt = NULL;
err = sqlite3_close(db);
if (err != SQLITE_OK)
goto error;
return (count);
error:
log(db);
if (stmt) sqlite3_finalize(stmt);
if (db) sqlite3_close(db);
return (0);
}
void testNormalPutIncludingNow()
{
SlidingWindow sw(0.25, true);
WNS_ASSERT_MAX_REL_ERROR( 0.0, sw.getAbsolute(), 1E-9 );
// simTime 0.0
sw.put(1.0);
WNS_ASSERT_MAX_REL_ERROR( 1.0, sw.getAbsolute(), 1E-9 );
wns::simulator::getEventScheduler()->scheduleDelay(events::NoOp(), 0.1);
wns::simulator::getEventScheduler()->processOneEvent();
// simTime 0.1
WNS_ASSERT_MAX_REL_ERROR( 1.0, sw.getAbsolute(), 1E-9 );
sw.put(2.3);
WNS_ASSERT_MAX_REL_ERROR( 3.3, sw.getAbsolute(), 1E-9 );
wns::simulator::getEventScheduler()->scheduleDelay(events::NoOp(), 0.1);
wns::simulator::getEventScheduler()->processOneEvent();
// simTime 0.2
WNS_ASSERT_MAX_REL_ERROR( 3.3, sw.getAbsolute(), 1E-9 );
sw.put(4.2);
WNS_ASSERT_MAX_REL_ERROR( 7.5, sw.getAbsolute(), 1E-9 );
wns::simulator::getEventScheduler()->scheduleDelay(events::NoOp(), 0.05);
wns::simulator::getEventScheduler()->processOneEvent();
// simTime 0.25
WNS_ASSERT_MAX_REL_ERROR( 7.5, sw.getAbsolute(), 1E-9 );
wns::simulator::getEventScheduler()->scheduleDelay(events::NoOp(), 0.05);
wns::simulator::getEventScheduler()->processOneEvent();
// simTime 0.3
WNS_ASSERT_MAX_REL_ERROR( 6.5, sw.getAbsolute(), 1E-9 );
wns::simulator::getEventScheduler()->scheduleDelay(events::NoOp(), 0.1);
wns::simulator::getEventScheduler()->processOneEvent();
// simTime 0.4
WNS_ASSERT_MAX_REL_ERROR( 4.2, sw.getAbsolute(), 1E-9 );
wns::simulator::getEventScheduler()->scheduleDelay(events::NoOp(), 0.1);
wns::simulator::getEventScheduler()->processOneEvent();
// simTime 0.5
WNS_ASSERT_MAX_REL_ERROR( 0.0, sw.getAbsolute(), 1E-9 );
}
bool
O2DatDB::
select(O2DatRecList &out)
{
#if TRACE_SQL_EXEC_TIME
stopwatch sw("select all");
#endif
sqlite3 *db = NULL;
sqlite3_stmt *stmt = NULL;
O2DatRec rec;
int err = sqlite3_open16(dbfilename.c_str(), &db);
if (err != SQLITE_OK)
goto error;
sqlite3_busy_timeout(db, 5000);
wchar_t *sql =
L"select"
COLUMNS
L" from dat;";
err = sqlite3_prepare16_v2(db, sql, wcslen(sql)*2, &stmt, NULL);
if (err != SQLITE_OK)
goto error;
while (sqlite3_step(stmt) == SQLITE_ROW) {
get_columns(stmt, rec);
out.push_back(rec);
}
sqlite3_finalize(stmt);
stmt = NULL;
err = sqlite3_close(db);
if (err != SQLITE_OK)
goto error;
return true;
error:
log(db);
if (stmt) sqlite3_finalize(stmt);
if (db) sqlite3_close(db);
return false;
}
void
testTwoAtTheSameTime()
{
SlidingWindow sw(0.25);
// simTime 0.0
sw.put(2.3);
sw.put(4.2);
wns::simulator::getEventScheduler()->scheduleDelay(events::NoOp(), 0.1);
wns::simulator::getEventScheduler()->processOneEvent();
// simTime 0.1
WNS_ASSERT_MAX_REL_ERROR( 6.5, sw.getAbsolute(), 1E-9 );
wns::simulator::getEventScheduler()->scheduleDelay(events::NoOp(), 0.2);
wns::simulator::getEventScheduler()->processOneEvent();
// simTime 0.3
WNS_ASSERT_MAX_REL_ERROR( 0.0, sw.getAbsolute(), 1E-9 );
}
bool
O2DatDB::
remove(const hashT &hash)
{
#if TRACE_SQL_EXEC_TIME
stopwatch sw("remove");
#endif
sqlite3 *db = NULL;
int err = sqlite3_open16(dbfilename.c_str(), &db);
if (err != SQLITE_OK)
goto error;
sqlite3_busy_timeout(db, 5000);
wchar_t *sql =
L"delete from dat where hash = ?;";
sqlite3_stmt *stmt = NULL;
err = sqlite3_prepare16_v2(db, sql, wcslen(sql)*2, &stmt, NULL);
if (err != SQLITE_OK)
goto error;
if (!bind(db, stmt, 1, hash))
goto error;
err = sqlite3_step(stmt);
if (err != SQLITE_ROW && err != SQLITE_DONE)
goto error;
sqlite3_finalize(stmt);
stmt = NULL;
err = sqlite3_close(db);
if (err != SQLITE_OK)
goto error;
return true;
error:
log(db);
if (stmt) sqlite3_finalize(stmt);
if (db) sqlite3_close(db);
return false;
}
void merge(int l,int m,int r){
int i, j, k;
int n1 = m - l + 1;
int n2 = r - m;
char L[n1][30], R[n2][30];
for (i = 0; i < n1; i++)
sw(L[i],s[l + i]);
for (j = 0; j < n2; j++)
R[j] = s[m + 1+ j];
i = 0;
j = 0;
k = l;
while (i < n1 && j < n2)
{
if (L[i] <= R[j])
{
arr[k] = L[i];
i++;
}
else
{
arr[k] = R[j];
j++;
}
k++;
}
while (i < n1)
{
arr[k] = L[i];
i++;
k++;
}
while (j < n2)
{
arr[k] = R[j];
j++;
k++;
}
}
uint64
O2DatDB::
select_totaldisksize(void)
{
#if TRACE_SQL_EXEC_TIME
stopwatch sw("select totakdisksize");
#endif
sqlite3 *db = NULL;
sqlite3_stmt *stmt = NULL;
int err = sqlite3_open16(dbfilename.c_str(), &db);
if (err != SQLITE_OK)
goto error;
sqlite3_busy_timeout(db, 5000);
wchar_t *sql = L"select sum(disksize) from dat;";
err = sqlite3_prepare16_v2(db, sql, wcslen(sql)*2, &stmt, NULL);
if (err != SQLITE_OK)
goto error;
err = sqlite3_step(stmt);
if (err != SQLITE_ROW && err != SQLITE_DONE)
goto error;
uint64 totalsize = sqlite3_column_int64(stmt,0);
sqlite3_finalize(stmt);
stmt = NULL;
err = sqlite3_close(db);
if (err != SQLITE_OK)
goto error;
return (totalsize);
error:
log(db);
if (stmt) sqlite3_finalize(stmt);
if (db) sqlite3_close(db);
return (0);
}
void qt_libxml_error_handler(void *ctx, const char *msg, ...)
{
va_list args;
QString message;
QStringList errorlined;
errorlined.clear();
int size = 256;
char * buf = new char[ size ];
while( 1 ) {
va_start(args, msg);
int retval = ::vsnprintf( buf, size, msg, args );
va_end(args);
if( -1 < retval && retval < size ) { // everything was OK
message = buf;
if (message.size() > 0) {
message.replace("&", "&");
errorlined.append(message);
/*qDebug() << "### 1 error captured to insert on class as list or so.... " << ;*/
}
break;
}
else if( retval > -1 ) { // buffer too small
size = retval + 1;
delete [] buf;
buf = new char[ size ];
}
else { // error
// ...
break;
}
}
delete [] buf;
QFile f( XMLERROR_FILE );
if ( f.open( QFile::Append | QFile::Text ) )
{
QTextStream sw( &f );
sw << errorlined.join("");
f.close();
}
}
inline void exponent_example(std::ostream& out_stream = std::cout)
{
out_str << "Testing tape contents for exponent of tdouble." << std::endl;
// Input values initialization.
std::vector<tdouble> X(1, 3.0);
// Declare the X vector as independent and start a tape recording.
cl::tape_start(X);
// Output calculations.
std::vector<tdouble> Y(1);
Y[0] = std::exp(-2.0 * X[0]);
out_str << "\nFunction Y = exp(-2.0 * X[0]) is being tested at X[0] = " << X[0] << std::endl;
// Declare a tape function and stop the tape recording.
cl::tfunc<double> f(X, Y);
// Calculate derivative in Forward mode.
std::vector<double> sy, sx(1, 1.0);
out_str << "\nTape operations sequence for differentiation of Y with respect to X[0]: ";
sy = f.forward(1, sx, out_stream);
out_str << "Derivative of Y with respect to X[0] in Forward mode has been calculated successfully:" << std::endl;
out_str << "\tdY / dX (X[0]) = " << sy[0] << std::endl;
// Calculate derivative in Reverse mode.
std::vector<double> sw(1, 1.0);
out_str << "\nTape operations sequence for differentiation of Y with respect to X: ";
sy = f.reverse(1, sw, out_stream);
out_str << "\nDerivative of Y with respect to X in Reverse mode has been calculated successfully:" << std::endl;
out_str << "\tdY / dX (X[0]) = " << sy[0] << std::endl;
out_str << std::endl << std::string(100, '-') << std::endl;
}
MatrixFloat LDA::computeWithinClassScatterMatrix( ClassificationData &data ){
MatrixFloat sw(numInputDimensions,numInputDimensions);
sw.setAllValues( 0 );
for(UINT k=0; k<numClasses; k++){
//Compute the scatter matrix for class k
ClassificationData classData = data.getClassData( data.getClassTracker()[k].classLabel );
MatrixFloat scatterMatrix = classData.getCovarianceMatrix();
//Add this to the main scatter matrix
for(UINT m=0; m<numInputDimensions; m++){
for(UINT n=0; n<numInputDimensions; n++){
sw[m][n] += scatterMatrix[m][n];
}
}
}
return sw;
}
const std::vector<some_row_concept_class> OutputFilteredRowsT(const InputRange_& range,
std::ostream& output_stream)
{
if (range.begin() != range.end())
{
stream_wrapper sw(output_stream);
sw.output_header(*range.begin());
output_stream << std::endl;
std::for_each(range.begin(),
range.end(),
[&](const some_row_concept_class& srcc) { sw.output_header(srcc); });
//in XE6 I can end this std::for_each with
// &sw.output_row);
//and everything is fine, but that is not actually compliant, so I use a
//lambda in coliru for the same effect
output_stream << std::endl;
}
return std::vector<some_row_concept_class>(range.begin(), range.end());
}
inline void IO::OutputScheduler::add_socket(const IO::Socket& sock,
const std::string& data) {
Log::i("socket with fd = " + std::to_string(sock.get_fd()) +
" will be copied to fd = ");
std::unique_ptr<IO::Socket> new_sock(new Socket(sock));
scheduled_write sw(std::move(new_sock), data);
_schedule.push_back(std::move(sw));
struct epoll_event ev;
memset(&ev, 0, sizeof(struct epoll_event));
ev.data.fd = (*_schedule.back().sock).get_fd();
ev.events = EPOLLOUT | EPOLLET;
Log::i(std::to_string((*_schedule.back().sock).get_fd()));
if (-1 == epoll_ctl(_efd, EPOLL_CTL_ADD, ev.data.fd, &ev))
throw std::runtime_error("Could not add event with fd:" +
std::to_string(sock.get_fd()));
}
void handleStatic(staticPage* Sp) {
Response& resp(*this->resp);
try {
String data=Sp->data;
int bufferL = resp.buffer.length();
if(Sp->mime.length()>0)resp.headers["Content-Type"]=Sp->mime;
{
char* tmps = sp.beginAdd(16);
int l = itoa(data.length(), tmps);
sp.endAdd(l);
resp.headers.insert({"Content-Length", { tmps, l }});
StreamWriter sw(resp.buffer);
resp.serializeHeaders(sw);
}
iov[0]= {resp.buffer.data()+bufferL, (size_t)(resp.buffer.length()-bufferL)};
iov[1]= {data.data(), (size_t)data.length()};
resp.outputStream->writevAll(iov, 2, { &handler::writevCB, this });
} catch(exception& ex) {
thr.handleError(req,resp,ex,{&handler::finalize,this});
}
}
void set_pivot_from_preferences(gfx::Transformation& t)
{
gfx::Transformation::Corners corners;
t.transformBox(corners);
gfx::PointT<double> nw(corners[gfx::Transformation::Corners::LEFT_TOP]);
gfx::PointT<double> ne(corners[gfx::Transformation::Corners::RIGHT_TOP]);
gfx::PointT<double> sw(corners[gfx::Transformation::Corners::LEFT_BOTTOM]);
gfx::PointT<double> se(corners[gfx::Transformation::Corners::RIGHT_BOTTOM]);
gfx::PointT<double> pivotPos((nw + se) / 2);
app::gen::PivotPosition pivot = Preferences::instance().selection.pivotPosition();
switch (pivot) {
case app::gen::PivotPosition::NORTHWEST:
pivotPos = nw;
break;
case app::gen::PivotPosition::NORTH:
pivotPos = (nw + ne) / 2.0;
break;
case app::gen::PivotPosition::NORTHEAST:
pivotPos = ne;
break;
case app::gen::PivotPosition::WEST:
pivotPos = (nw + sw) / 2.0;
break;
case app::gen::PivotPosition::EAST:
pivotPos = (ne + se) / 2.0;
break;
case app::gen::PivotPosition::SOUTHWEST:
pivotPos = sw;
break;
case app::gen::PivotPosition::SOUTH:
pivotPos = (sw + se) / 2.0;
break;
case app::gen::PivotPosition::SOUTHEAST:
pivotPos = se;
break;
}
t.displacePivotTo(gfx::PointF(pivotPos));
}
static inline void printStackTrace ( FILE * out )
{
#ifdef GNUC
// storage array for stack trace address data
void* addrlist[ 128 + 1 ];
// retrieve current stack addresses
uint32_t addrlen = backtrace ( addrlist, sizeof ( addrlist ) / sizeof ( void* ) );
if( addrlen == 0 )
{
fprintf ( out, " (no trace - stack may be corrupted) \n" );
return;
}
// create readable strings to each frame.
backtrace_symbols_fd ( addrlist, addrlen, fileno(out) );
#else
StackWalker_OutFile sw(out);
sw.ShowCallstack ();
#endif
}
void test_switch_by_resistor()
{
ngdc dc("dc", 10);
ngresistor r("r1", 370);
ngled led("led1", 5e-3);
ngswitch sw("sw", ngswitch::off);
ngground gnd;
ngline l0(dc.neg, gnd.p1);
ngline l1(dc.pos, r.p1);
ngline l2(r.p2, led.p1);
ngline l3(led.p2, sw.p1);
ngline l4(sw.p2, dc.neg);
schema sch;
sch.AddDevices(&dc, &r, &led, &gnd, &sw, 0);
sch.AddLines(&l0, &l1, &l2, &l3, &l4, 0);
circuit cir(&sch);
cir.Tran("1t", "1m");
do
{
Sleep(200);
char ch = getchar();
switch (ch)
{
case 'a':
cir.SwitchOver(&sw);
Sleep(200);
break;
case 'q':
cir.Halt();
default:
break;
};
} while (cir.IsRunning());
}
demux(){
#define demux Vdemux
int count = 6;
unsigned char c, temp;
while(!rebootflag)
{
while(hostops->rcvq->c_cc==0) sw(0); /* nothing for us to do */
if (!ENCODE_ENABLE) precv((char)qgetc(hostops->rcvq)); /* read packet */
else
if ((c = (char)qgetc(hostops->rcvq)) == -1) precv((char) c);
else
if ((c & 0xe0) == 0x20 || (count+=2) == 8)
{
count = 0;
temp = c;
}
else precv((char)((c & 0x3f) | ((temp << count) & 0xc0)));
}
nap(60); /* let output queue drain */
reboot();
}
