static void epia_read_block( PIA *pi, char * buf, int count )
{ int k, ph, a, b;
switch (pi->mode) {
case 0: w0(0x81); w2(1); w2(3); w0(0xc1);
ph = 1;
for (k=0;k<count;k++) {
w2(2+ph); a = r1();
w2(4+ph); b = r1();
buf[k] = j44(a,b);
ph = 1 - ph;
}
w0(0); w2(4);
break;
case 1: w0(0x91); w2(1); w0(0x10); w2(3);
w0(0x51); w2(5); w0(0xd1);
ph = 1;
for (k=0;k<count;k++) {
w2(4+ph);
a = r1(); b = r2();
buf[k] = j53(a,b);
ph = 1 - ph;
}
w0(0); w2(4);
break;
case 2: w0(0x89); w2(1); w2(0x23); w2(0x21);
ph = 1;
for (k=0;k<count;k++) {
w2(0x24+ph);
buf[k] = r0();
ph = 1 - ph;
}
w2(6); w2(4);
break;
case 3: if (count > 512) WR(0x84,3);
w3(0); w2(0x24);
for (k=0;k<count;k++) buf[k] = r4();
w2(4); WR(0x84,0);
break;
case 4: if (count > 512) WR(0x84,3);
w3(0); w2(0x24);
for (k=0;k<count/2;k++) ((u16 *)buf)[k] = r4w();
w2(4); WR(0x84,0);
break;
case 5: if (count > 512) WR(0x84,3);
w3(0); w2(0x24);
for (k=0;k<count/4;k++) ((u32 *)buf)[k] = r4l();
w2(4); WR(0x84,0);
break;
}
}
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
DeviceViewer w;
QTextCodec *codec = QTextCodec::codecForName("CP1251");
QTextCodec::setCodecForLocale(codec);
/****Add Test Devices ****/
QList<MemRegion> memList;
MemRegion r1("Region1", rand(),"EEPROM1",0, 256*256*14);
MemRegion r2("Region2", rand(),"EEPROM2",256*256*14, 256*256*25);
MemRegion r3("Region3", rand(),"EEPROM3",256*256*25, 256*256*40);
MemRegion r4("Region4", rand(),"EEPROM1",256*256*40, 256*256*58);
MemRegion r5("Region5", rand(),"EEPROM2",256*256*58, 256*256*80);
MemRegion r6("Region6", rand(),"EEPROM3",256*256*80, 256*256*99);
memList << r1 << r2 << r3 << r4 << r5 << r6;
QList<Node> nodeList;
for(int i = 0; i < 9; i++){
Node n;
n.serialNum = rand();
n.info = QString("Something about node %1 of Device1").arg(i);
nodeList << n;
}
Device dev1("Device1", "Т0000255", nodeList, memList);
nodeList.clear();
for(int i = 0; i < 6; i++){
Node n;
n.serialNum = rand();
n.info = QString("Something about node %1 of Device2").arg(i);
nodeList << n;
}
Device dev2("Device2", "И0000364", nodeList, memList);
nodeList.clear();
for(int i = 0; i < 3; i++){
Node n;
n.serialNum = rand();
n.info = QString("Something about node %1 of Device3").arg(i);
nodeList << n;
}
Device dev3("Device3", "Я0000982", nodeList, memList);
w.addDevice(&dev1);
w.addDevice(&dev2);
w.addDevice(&dev3);
/*************************/
w.show();
return a.exec();
}
static void kbic_read_block( PIA *pi, char * buf, int count )
{ int k, a, b;
switch (pi->mode) {
case 0: w0(0x98); w2(4); w2(6); w2(4);
for (k=0;k<count/2;k++) {
w2(1); w0(8); a = r1();
w0(0x28); b = r1();
buf[2*k] = j44(a,b);
w2(5); b = r1();
w0(8); a = r1();
buf[2*k+1] = j44(a,b);
w2(4);
}
break;
case 1: w0(0xb8); w2(4); w2(6); w2(4);
for (k=0;k<count/4;k++) {
w0(0xb8);
w2(4); w2(5);
w0(8); buf[4*k] = j53(r12w());
w0(0xb8); buf[4*k+1] = j53(r12w());
w2(4); w2(5);
buf[4*k+3] = j53(r12w());
w0(8); buf[4*k+2] = j53(r12w());
}
w2(4);
break;
case 2: w0(0x88); w2(4); w2(6); w2(4);
for (k=0;k<count/2;k++) {
w2(0xa0); w2(0xa1); buf[2*k] = r0();
w2(0xa5); buf[2*k+1] = r0();
}
w2(4);
break;
case 3: w0(0xa0); w2(4); w2(6); w2(4); w3(0);
for (k=0;k<count;k++) buf[k] = r4();
w2(4); w2(0); w2(4);
break;
case 4: w0(0xa0); w2(4); w2(6); w2(4); w3(0);
for (k=0;k<count/2;k++) ((u16 *)buf)[k] = r4w();
w2(4); w2(0); w2(4);
break;
case 5: w0(0xa0); w2(4); w2(6); w2(4); w3(0);
for (k=0;k<count/4;k++) ((u32 *)buf)[k] = r4l();
w2(4); w2(0); w2(4);
break;
}
}
/* Public functions */
void VGCRectangleTest::run(){
VGCRectangle r0;
VGCAssert(VGCVector(0, 0) == r0.getPosition());
VGCAssert(0 == r0.getWidth());
VGCAssert(0 == r0.getHeight());
r0.setPosition(VGCVector(1, 2));
VGCAssert(VGCVector(1, 2) == r0.getPosition());
r0.setWidth(1);
VGCAssert(1 == r0.getWidth());
r0.setHeight(2);
VGCAssert(2 == r0.getHeight());
VGCRectangle r1(VGCVector(1, 2), 1, 2);
VGCAssert(VGCVector(1, 2) == r1.getPosition());
VGCAssert(1 == r1.getWidth());
VGCAssert(2 == r1.getHeight());
VGCRectangle r2(r1);
VGCAssert(VGCVector(1, 2) == r2.getPosition());
VGCAssert(1 == r2.getWidth());
VGCAssert(2 == r2.getHeight());
VGCRectangle r3;
r3 = r2;
VGCAssert(VGCVector(1, 2) == r3.getPosition());
VGCAssert(1 == r3.getWidth());
VGCAssert(2 == r3.getHeight());
VGCRectangle r4(VGCVector(1, 2), 2, 3);
VGCAssert(r4.isInside(VGCVector(1, 2)));
VGCAssert(r4.isInside(VGCVector(2, 2)));
VGCAssert(r4.isInside(VGCVector(1, 3)));
VGCAssert(r4.isInside(VGCVector(2, 3)));
VGCAssert(r4.isInside(VGCVector(1, 4)));
VGCAssert(r4.isInside(VGCVector(2, 4)));
VGCAssert(!r4.isInside(VGCVector(0, 3)));
VGCAssert(!r4.isInside(VGCVector(2, 5)));
VGCRectangle a0(VGCVector(0, 0), 0, 0);
VGCRectangle a1(VGCVector(0, 0), 0, 1);
VGCRectangle a2(VGCVector(0, 0), 1, 0);
VGCRectangle a3(VGCVector(0, 1), 0, 0);
VGCRectangle b0(VGCVector(0, 0), 0, 0);
VGCRectangle b1(VGCVector(0, 0), 0, 1);
VGCRectangle b2(VGCVector(0, 0), 1, 0);
VGCRectangle b3(VGCVector(0, 1), 0, 0);
VGCAssert(a0 == b0);
VGCAssert(a1 == b1);
VGCAssert(a2 == b2);
VGCAssert(a3 == b3);
VGCAssert(a0 != a1);
VGCAssert(a0 != a2);
VGCAssert(a0 != a3);
}
TEST(buffer, buffer_agg_avg)
{
Buffer buf;
buf.set_aggmode(Buffer::AVG);
ReadingIdentifier::Ptr pRid;
struct timeval t1;
t1.tv_sec = 1;
t1.tv_usec = 0;
{
Reading r1(1.0, t1, pRid);
buf.push(r1);
buf.aggregate(0, false);
// now assert exact one, not deleted:
ASSERT_EQ(buf.size(), (size_t)1);
Reading &r = *buf.begin();
ASSERT_TRUE(!r.deleted());
// first case: no prev. value, just one data -> return value as AVG.
ASSERT_EQ(r.value(), 1.0);
r.mark_delete();
}
// now add a 2nd value:
{
t1.tv_sec = 2;
Reading r2(2.0, t1, pRid);
buf.push(r2);
buf.aggregate(0, false);
buf.clean();
ASSERT_EQ(buf.size(), (size_t)1);
Reading &r = *buf.begin();
ASSERT_TRUE(!r.deleted());
// 2nd case: prev. value (1.0 at 1s), just one new data (2.0 at 2s)-> return 1.0 as AVG (2.0 has no time yet!)
ASSERT_EQ(r.value(), 1.0);
r.mark_delete();
}
// now add 2 values:
{
t1.tv_sec = 4;
Reading r3(3.0, t1, pRid);
buf.push(r3);
t1.tv_sec = 7;
Reading r4(4.0, t1, pRid);
buf.push(r4);
buf.aggregate(0, false);
buf.clean();
ASSERT_EQ(buf.size(), (size_t)1);
Reading &r = *buf.begin();
ASSERT_TRUE(!r.deleted());
// 3rd case: prev. value (2.0 at 2s), two new data (3.0 at 4s and 4.0 at 7s)-> return (2*2+3*3)/5 as AVG (4.0 has no time yet!)
ASSERT_EQ(((2.0*2.0)+(3.0*3.0))/5.0, r.value());
r.mark_delete();
}
}
CCreateWaveDlg::CCreateWaveDlg(CWnd* pParent /*=NULL*/)
: CDialog(CCreateWaveDlg::IDD, pParent)
{
// IDD_CREATEWAV DIALOGEX 0, 0, 151, 173
CRect rect(CPoint(0,0),CSize(151,173));
MapDialogRect(&rect);
setFixedSize(rect.Width(),rect.Height());
// DEFPUSHBUTTON "Begin",IDC_BEGIN,37,152,52,14
CButton* mfc1 = new CButton(this);
CRect r1(CPoint(37,152),CSize(52,14));
MapDialogRect(&r1);
mfc1->Create(_T("Begin"),0,r1,this,IDC_BEGIN);
mfc1->setDefault(true);
mfcToQtWidget.insert(IDC_BEGIN,mfc1);
QObject::connect(mfc1,SIGNAL(clicked()),this,SLOT(begin_clicked()));
// PUSHBUTTON "Cancel",IDCANCEL,92,152,52,14
CButton* mfc2 = new CButton(this);
CRect r2(CPoint(92,152),CSize(52,14));
MapDialogRect(&r2);
mfc2->Create(_T("Cancel"),0,r2,this,IDCANCEL);
mfcToQtWidget.insert(IDCANCEL,mfc2);
QObject::connect(mfc2,SIGNAL(clicked()),this,SLOT(cancel_clicked()));
// GROUPBOX "Song length",IDC_STATIC,7,7,137,47
CGroupBox* mfc3 = new CGroupBox(this);
mfc3->setTitle("Song length");
CRect r3(CPoint(7,7),CSize(137,47));
MapDialogRect(&r3);
mfc3->setGeometry(r3);
// IDC_STATIC do not get added to MFC-to-Qt map.
// CONTROL "Play the song",IDC_RADIO_LOOP,"Button",BS_AUTORADIOBUTTON,14,20,59,10
CButton* mfc4 = new CButton(this);
CRect r4(CPoint(14,20),CSize(59,10));
MapDialogRect(&r4);
mfc4->Create(_T("Play the song"),BS_AUTORADIOBUTTON,r4,this,IDC_RADIO_LOOP);
mfcToQtWidget.insert(IDC_RADIO_LOOP,mfc4);
QObject::connect(mfc4,SIGNAL(clicked()),this,SLOT(radioLoop_clicked()));
// CONTROL "Play for",IDC_RADIO_TIME,"Button",BS_AUTORADIOBUTTON,14,38,41,10
CButton* mfc5 = new CButton(this);
CRect r5(CPoint(14,38),CSize(41,10));
MapDialogRect(&r5);
mfc5->Create(_T("Play for"),BS_AUTORADIOBUTTON,r5,this,IDC_RADIO_TIME);
mfcToQtWidget.insert(IDC_RADIO_TIME,mfc5);
QObject::connect(mfc5,SIGNAL(clicked()),this,SLOT(radioTime_clicked()));
// EDITTEXT IDC_TIMES,73,19,36,12,ES_AUTOHSCROLL
// CONTROL "",IDC_SPIN_LOOP,"msctls_updown32",UDS_ALIGNRIGHT | UDS_AUTOBUDDY | UDS_ARROWKEYS,105,17,11,17
// LTEXT "time(s)",IDC_STATIC,115,20,21,10,SS_CENTERIMAGE
// EDITTEXT IDC_SECONDS,53,37,44,12,ES_AUTOHSCROLL
// CONTROL "",IDC_SPIN_TIME,"msctls_updown32",UDS_ALIGNRIGHT | UDS_AUTOBUDDY | UDS_ARROWKEYS,93,36,11,14
// LTEXT "mm:ss",IDC_STATIC,106,38,21,10,SS_CENTERIMAGE
// GROUPBOX "Channels",IDC_STATIC,7,60,137,87
// LISTBOX IDC_CHANNELS,14,71,124,70,LBS_OWNERDRAWFIXED | LBS_HASSTRINGS | LBS_NOINTEGRALHEIGHT | WS_VSCROLL | WS_TABSTOP
}
void test_base() {
Range16 r(0, 5);
BOOST_CHECK(r.length() == 6);
BOOST_CHECK(r.begin() == 0);
BOOST_CHECK(r.end() == 5);
BOOST_CHECK(r.contains(0));
BOOST_CHECK(r.contains(3));
BOOST_CHECK(r.contains(5));
BOOST_CHECK(!r.contains(6));
BOOST_CHECK(!r.contains(100));
BOOST_CHECK_THROW(r.begin(6), std::exception);
BOOST_CHECK_NO_THROW(r.begin(5));
BOOST_CHECK(r.length() == 1);
BOOST_CHECK_NO_THROW(r.end(10));
BOOST_CHECK(r.begin() == 5);
BOOST_CHECK(r.end() == 10);
BOOST_CHECK(r.length() == 6);
Range16 r1(0, 5);
Range16 r2(0, 2);
BOOST_CHECK(r1.contains(r2));
BOOST_CHECK(r1.contains(0, 0));
BOOST_CHECK(r1.contains(Range16(5, 5)));
BOOST_CHECK(r1.contains(5, 6));
BOOST_CHECK(!r1.contains(6, 6));
BOOST_CHECK(r1.containsFull(r2));
BOOST_CHECK(r1.containsFull(0, 4));
BOOST_CHECK(r1.containsFull(0, 5));
BOOST_CHECK(!r1.containsFull(0, 6));
BOOST_CHECK(r1.containsFull(5, 5));
BOOST_CHECK(r1.containsFull(Range16(1, 5)));
BOOST_CHECK(!r1.containsFull(Range16(6, 6)));
BOOST_CHECK(!r1.containsFull(5, 10));
Range16 r3(20, 30);
Range16 r4( 3, 10);
BOOST_CHECK(!r3.contains(r4));
BOOST_CHECK(!r3.borders(r4));
// test comparison operators
BOOST_CHECK(r1 != r2);
BOOST_CHECK(r2 != r1);
BOOST_CHECK(r3 != r4);
// BOOST_CHECK(r3 > r4);
// BOOST_CHECK(r4 < r3);
}
void
OpenSteer::
BoxObstacle::
findIntersectionWithVehiclePath (const AbstractVehicle& vehicle,
PathIntersection& pi) const
{
// abbreviations
const float w = width; // dimensions
const float h = height;
const float d = depth;
const Vec3 s = side (); // local space
const Vec3 u = up ();
const Vec3 f = forward ();
const Vec3 p = position ();
const Vec3 hw = s * (0.5f * width); // offsets for face centers
const Vec3 hh = u * (0.5f * height);
const Vec3 hd = f * (0.5f * depth);
const seenFromState sf = seenFrom ();
// the box's six rectangular faces
RectangleObstacle r1 (w, h, s, u, f, p + hd, sf); // front
RectangleObstacle r2 (w, h, -s, u, -f, p - hd, sf); // back
RectangleObstacle r3 (d, h, -f, u, s, p + hw, sf); // side
RectangleObstacle r4 (d, h, f, u, -s, p - hw, sf); // other side
RectangleObstacle r5 (w, d, s, -f, u, p + hh, sf); // top
RectangleObstacle r6 (w, d, -s, -f, -u, p - hh, sf); // bottom
// group the six RectangleObstacle faces together
ObstacleGroup faces;
faces.push_back (&r1);
faces.push_back (&r2);
faces.push_back (&r3);
faces.push_back (&r4);
faces.push_back (&r5);
faces.push_back (&r6);
// find first intersection of vehicle path with group of six faces
PathIntersection next;
firstPathIntersectionWithObstacleGroup (vehicle, faces, pi, next);
// when intersection found, adjust PathIntersection for the box case
if (pi.intersect)
{
pi.obstacle = this;
pi.steerHint = ((pi.surfacePoint - position ()).normalize () *
(pi.vehicleOutside ? 1.0f : -1.0f));
}
}
static void on26_read_block( PIA *pi, char * buf, int count )
{ int k, a, b;
switch (pi->mode) {
case 0: w0(1); P1; w0(1); P2; w0(2); P1; w0(0x18); P2; w0(0); P1;
udelay(10);
for (k=0;k<count;k++) {
w2(6); a = r1();
w2(4); b = r1();
buf[k] = j44(a,b);
}
w0(2); P1; w0(8); P2;
break;
case 1: w0(1); P1; w0(1); P2; w0(2); P1; w0(0x19); P2; w0(0); P1;
udelay(10);
for (k=0;k<count/2;k++) {
w2(0x26); buf[2*k] = r0();
w2(0x24); buf[2*k+1] = r0();
}
w0(2); P1; w0(9); P2;
break;
case 2: w3(1); w3(1); w2(5); w4(1); w2(4);
w3(0); w3(0); w2(0x24);
udelay(10);
for (k=0;k<count;k++) buf[k] = r4();
w2(4);
break;
case 3: w3(1); w3(1); w2(5); w4(1); w2(4);
w3(0); w3(0); w2(0x24);
udelay(10);
for (k=0;k<count/2;k++) ((u16 *)buf)[k] = r4w();
w2(4);
break;
case 4: w3(1); w3(1); w2(5); w4(1); w2(4);
w3(0); w3(0); w2(0x24);
udelay(10);
for (k=0;k<count/4;k++) ((u32 *)buf)[k] = r4l();
w2(4);
break;
}
}
cli::Error_e cmdValKey( CLIARGS args, cli::Param_t prm) {
typedef ValKeyA ValKey;
{ ValKey r( "jhcValKeyRoot", "k1", true );
r.SetVal( "String1", "Helloo" );
r.SetVal( "Dword1" , 1111 );
{ ValKey r2( r, "k2", true );
r2.SetVal( "String2", "Helloo22" );
r2.SetVal( "Dword2" , 2222 );
r2.SetVal( "Dword3" , 3333 );
{ ValKey r3( r2, "k3", true );
r3.SetVal( "Dword4" , 4444 );
DumpKey( r3 );
}
ValKey r4( r, "k4" );
r4.SetVal( "Dword5", 5555 );
DumpKey( r2 );
DumpKey( r4 );
}
r.SetVal( "Dword6" , 6666 );
DumpKey( r );
}
// char sz[100]; memset( sz, 0, sizeof sz );
// r.GetVal( "String1" , sz, 100 ); printf( "String1: %s\n", sz );
// r.GetVal( "k2\\String2", sz, 100 ); printf( "String2: %s\n", sz );
//
// DWORD dw = 0;
// r.GetVal( "k3\\Dword1" , dw ); printf( "Dword1: %u\n", dw );
// r.GetVal( "k4\\Dword2" , dw ); printf( "Dword2: %u\n", dw );
// r.GetVal( "k4\\k5\\Dword3", dw ); printf( "Dword3: %u\n", dw );
printf("\n");
printf("\n");
ValStore<char> VS;
VS.Deserialize( "jhcValKeyRoot" );
VS.Dump( ConOut );
return cli::ERR_GENERAL;
}
// Return a matrix to represent a displacement of the given vector.
Matrix4x4 translation(const Vector3D& displacement)
{
Matrix4x4 t;
// Fill me in!
double x = displacement[0];
double y = displacement[1];
double z = displacement[2];
Vector4D r1(1, 0, 0, x);
Vector4D r2(0, 1, 0, y);
Vector4D r3(0, 0, 1, z);
Vector4D r4(0, 0, 0, 1);
t = Matrix4x4(r1,r2,r3,r4);
return t;
}
// Return a matrix to represent a nonuniform scale with the given factors.
Matrix4x4 scaling(const Vector3D& scale)
{
Matrix4x4 s;
double x = scale[0];
double y = scale[1];
double z = scale[2];
Vector4D r1(x, 0, 0, 0);
Vector4D r2(0, y, 0, 0);
Vector4D r3(0, 0, z, 0);
Vector4D r4(0, 0, 0, 1);
s = Matrix4x4(r1,r2,r3,r4);
return s;
}
int main()
{
MALib::LOG_Initialize(true);
MALib::RANDOM_Initialize();
MALib::RECT r1(24, 24, 320, 320);
MALib::RECT r2(1, 4, 32, 21);
MALib::RECT r3(280, 150, 340, 180);
MALib::RECT r4(48, 60, 300, 280);
MALib::LOG_Out1Bool("RECT TEST SHOULD BE FALSE", MALib::Clipping(r1, r2));
MALib::LOG_Out1Bool("RECT TEST SHOULD BE TRUE ", MALib::Clipping(r1, r3));
MALib::LOG_Out1Bool("RECT TEST SHOULD BE TRUE ", MALib::Clipping(r1, r4));
MALib::LOG_Out1Bool("RECT TEST SHOULD BE FALSE", MALib::InsideRect(r1, MALib::POINT(1, 23)));
MALib::LOG_Out1Bool("RECT TEST SHOULD BE TRUE ", MALib::InsideRect(r1, MALib::POINT(190, 320)));
MALib::POINT p1 = MALib::Displacement(r1, MALib::RECT(480, 24, 560, 380));
MALib::POINT p2 = MALib::Displacement(r1, MALib::RECT(-128, 2, 80, -240));
MALib::LOG_Out2i("DISLPACEMENT TEXT", p1.x, p1.y);
MALib::LOG_Out2i("DISLPACEMENT TEXT", p2.x, p2.y);
r1.resize(120, 120);
bool t1 = MALib::INPUT::MOUSE.left;
MALib::SURFACE* s = 0;
MALib::CreateSurface(&s, "", 10200, 6600, MALib::PIXELFORMAT_BGR, 0);
//MALib::ExportBMPFile("test_big.bmp", s);
MALib::FreeSurface(&s);
MALib::LOG_Out1i("2 POW 2", MALib::Pow(2u, 2u));
MALib::LOG_Out1i("3 POW 4", MALib::Pow(3u, 4u));
MALib::LOG_Out1i("9 POW 0", MALib::Pow(9, 0u));
MALib::LOG_Out1i("-4 POW 3", MALib::Pow(-4, 3u));
MALib::LOG_Out1f("2, 2 MAGNITUDE", MALib::Magnitude(MALib::POINT(2, 2)));
MALib::LOG_Out1f("0, -4 MAGNITUDE", MALib::Magnitude(MALib::POINT(0, -4)));
MALib::LOG_Out1f("(2, 2) (7, 4) DISTANCE", MALib::Distance(MALib::POINT(2, 2), MALib::POINT(7, 4)));
MALib::LOG_Out1f("(-3, 2) (-6, 0) DISTANCE", MALib::Distance(MALib::POINT(-3, 2), MALib::POINT(-6, 0)));
MALib::LOG_Unitialize();
return 0;
}
int main( int argc, char* argv [ ] )
{
rational r1( 1, 2 );
rational r2( -2, 7 );
rational r3( 1, 3 );
rational r4( 2, 8 );
matrix m1 = { { r1, r2 }, { r3, r4 } };
std::cout << m1 << "\n";
r1 = rational(1, -3);
r2 = rational(2, 5);
r3 = rational(2, 7);
r4 = rational(-1, 7);
matrix m2 = { { r1, r2 }, { r3, r4 } };
std::cout << m2 << "\n";
matrix m12 = m1 * m2;
std::cout << m12 << "\n";
std::cout << m1.inverse() << "\n" << m1.determinant() << "\n";
}
void constructProblem(int nElements, int nBits, int nPartitions, int nTime, char * fileName) {
srand(time(NULL));
Cronometro c(Cronometro::NANO_S);
c.start();
gmp_randclass r4(gmp_randinit_default);
r4.seed(c.elapsed());
c.end();
ofstream filestr(fileName);
filestr << nTime << endl;
filestr << "~" << endl;
filestr << nElements << endl;
filestr << "~" << endl;
filestr << nPartitions << endl;
filestr << "~" << endl;
for (int i = 0; i < nElements; i++) {
mpz_class num(r4.get_z_bits(nBits));
filestr << num << endl;
}
filestr.close();
}
bool QMLManager::checkDuration(DiveObjectHelper *myDive, struct dive *d, QString duration)
{
if (myDive->duration() != duration) {
int h = 0, m = 0, s = 0;
QRegExp r1(QStringLiteral("(\\d*)\\s*%1[\\s,:]*(\\d*)\\s*%2[\\s,:]*(\\d*)\\s*%3").arg(tr("h")).arg(tr("min")).arg(tr("sec")), Qt::CaseInsensitive);
QRegExp r2(QStringLiteral("(\\d*)\\s*%1[\\s,:]*(\\d*)\\s*%2").arg(tr("h")).arg(tr("min")), Qt::CaseInsensitive);
QRegExp r3(QStringLiteral("(\\d*)\\s*%1").arg(tr("min")), Qt::CaseInsensitive);
QRegExp r4(QStringLiteral("(\\d*):(\\d*):(\\d*)"));
QRegExp r5(QStringLiteral("(\\d*):(\\d*)"));
QRegExp r6(QStringLiteral("(\\d*)"));
if (r1.indexIn(duration) >= 0) {
h = r1.cap(1).toInt();
m = r1.cap(2).toInt();
s = r1.cap(3).toInt();
} else if (r2.indexIn(duration) >= 0) {
h = r2.cap(1).toInt();
m = r2.cap(2).toInt();
} else if (r3.indexIn(duration) >= 0) {
m = r3.cap(1).toInt();
} else if (r4.indexIn(duration) >= 0) {
h = r4.cap(1).toInt();
m = r4.cap(2).toInt();
s = r4.cap(3).toInt();
} else if (r5.indexIn(duration) >= 0) {
h = r5.cap(1).toInt();
m = r5.cap(2).toInt();
} else if (r6.indexIn(duration) >= 0) {
m = r6.cap(1).toInt();
}
d->dc.duration.seconds = d->duration.seconds = h * 3600 + m * 60 + s;
if (same_string(d->dc.model, "manually added dive")) {
free(d->dc.sample);
d->dc.sample = 0;
d->dc.samples = 0;
} else {
qDebug() << "changing the duration on a dive that wasn't manually added - Uh-oh";
}
return true;
}
return false;
}
static void dstr_read_block( PIA *pi, char * buf, int count )
{ int k, a, b;
w0(0x81); P1;
if (pi->mode) { w0(0x19); } else { w0(9); }
P2; w0(0x82); P1; P3; w0(0x20); P1;
switch (pi->mode) {
case 0: for (k=0;k<count;k++) {
w2(6); a = r1(); w2(4);
w2(6); b = r1(); w2(4);
buf[k] = j44(a,b);
}
break;
case 1: w0(0);
for (k=0;k<count;k++) {
w2(0x26); buf[k] = r0(); w2(0x24);
}
w2(4);
break;
case 2: w2(0x24);
for (k=0;k<count;k++) buf[k] = r4();
w2(4);
break;
case 3: w2(0x24);
for (k=0;k<count/2;k++) ((u16 *)buf)[k] = r4w();
w2(4);
break;
case 4: w2(0x24);
for (k=0;k<count/4;k++) ((u32 *)buf)[k] = r4l();
w2(4);
break;
}
}
TEST( rect, aside ) {
canvas::Rect r1(100,100,100,100);
canvas::Rect r2(100,100,10,100);
canvas::Rect r3(190,100,10,100);
canvas::Rect r4(100,100,100,10);
canvas::Rect r5(100,190,100,10);
canvas::Rect r6(125,125,50,50);
ASSERT_TRUE(r2.aside(r1));
ASSERT_TRUE(r3.aside(r1));
ASSERT_TRUE(r4.aside(r1));
ASSERT_TRUE(r5.aside(r1));
ASSERT_FALSE(r6.aside(r1));
ASSERT_FALSE(r1.aside(r1));
ASSERT_FALSE(r1.aside(r2));
ASSERT_FALSE(r1.aside(r3));
ASSERT_FALSE(r1.aside(r4));
ASSERT_FALSE(r1.aside(r5));
ASSERT_FALSE(r1.aside(r6));
}
void alignedvector3()
{
Scalar s1 = internal::random<Scalar>();
Scalar s2 = internal::random<Scalar>();
typedef Matrix<Scalar,3,1> RefType;
typedef Matrix<Scalar,3,3> Mat33;
typedef AlignedVector3<Scalar> FastType;
RefType r1(RefType::Random()), r2(RefType::Random()), r3(RefType::Random()),
r4(RefType::Random()), r5(RefType::Random()), r6(RefType::Random());
FastType f1(r1), f2(r2), f3(r3), f4(r4), f5(r5), f6(r6);
Mat33 m1(Mat33::Random());
VERIFY_IS_APPROX(f1,r1);
VERIFY_IS_APPROX(f4,r4);
VERIFY_IS_APPROX(f4+f1,r4+r1);
VERIFY_IS_APPROX(f4-f1,r4-r1);
VERIFY_IS_APPROX(f4+f1-f2,r4+r1-r2);
VERIFY_IS_APPROX(f4+=f3,r4+=r3);
VERIFY_IS_APPROX(f4-=f5,r4-=r5);
VERIFY_IS_APPROX(f4-=f5+f1,r4-=r5+r1);
VERIFY_IS_APPROX(f5+f1-s1*f2,r5+r1-s1*r2);
VERIFY_IS_APPROX(f5+f1/s2-s1*f2,r5+r1/s2-s1*r2);
VERIFY_IS_APPROX(m1*f4,m1*r4);
VERIFY_IS_APPROX(f4.transpose()*m1,r4.transpose()*m1);
VERIFY_IS_APPROX(f2.dot(f3),r2.dot(r3));
VERIFY_IS_APPROX(f2.cross(f3),r2.cross(r3));
VERIFY_IS_APPROX(f2.norm(),r2.norm());
VERIFY_IS_APPROX(f2.normalized(),r2.normalized());
VERIFY_IS_APPROX((f2+f1).normalized(),(r2+r1).normalized());
f2.normalize();
r2.normalize();
VERIFY_IS_APPROX(f2,r2);
}
void *show_yes_no(void *t, void *msg, void *y, void *n)
{
p_ref r1(t),r2(msg),r3(y),r4(n);
t=eval(t); msg=eval(msg); y=eval(y); n=eval(n);
int c;
char *yes=lstring_value(y);
char *no=lstring_value(n);
do
{
dprintf("\n\n\n\n\n%s\n\n",lstring_value(t));
void *v=msg;
if (item_type(v)==L_CONS_CELL)
while (v) { dprintf("** %s\n",lstring_value(CAR(v))); v=CDR(v); }
else dprintf("** %s\n",lstring_value(v));
char msg[100];
fgets(msg,100,stdin);
c=msg[0];
} while (toupper(c)!=toupper(yes[0]) && toupper(c)!=toupper(no[0]));
if (toupper(c)==toupper(yes[0]))
return true_symbol;
else return NULL;
}
void Ray2Tests::testRectIntersections()
{
Rect2 rect(Vector2(1.0f, 1.0f), Vector2(4.0f, 4.0f));
Ray2 r1(Vector2(-1.0f, 2.0f), Vector2(1.0f, 0.0f)); // Enter from left
Ray2 r2(Vector2(5.0f, 2.0f), Vector2(-1.0f, 0.0f)); // right
Ray2 r3(Vector2(2.0f, -1.0f), Vector2(0.0f, 1.0f)); // bottom
Ray2 r4(Vector2(2.0f, 5.0f), Vector2(0.0f, -1.0f)); // top
Ray2 r5(Vector2(-1.0f, 2.0f), Vector2(-1.0f, 0.0f)); // Outside left
Ray2 r6(Vector2(5.0f, 2.0f), Vector2(1.0f, 0.0f)); // right
Ray2 r7(Vector2(2.0f, -1.0f), Vector2(0.0f, -1.0f)); // bottom
Ray2 r8(Vector2(2.0f, 5.0f), Vector2(0.0f, 1.0f)); // top
Ray2 r9(Vector2(2.0f, 2.0f), Vector2(1.0f, 1.0f)); // Inside out
Ray2 r10(Vector2(2.0f, 3.0f), Vector2(1.0f, -2.0f)); // Inside out
Ray2 r11(Vector2(1.2f, 3.0f), Vector2(-1.0f, -2.0f)); // Inside out
Ray2 r12(Vector2(1.2f, 5.0f), Vector2(1.2f, 1.0f)); // Outside
CPTAssert(r1.intersect(rect));
CPTAssert(r2.intersect(rect));
CPTAssert(r3.intersect(rect));
CPTAssert(r4.intersect(rect));
CPTAssert(!r5.intersect(rect));
CPTAssert(!r6.intersect(rect));
CPTAssert(!r7.intersect(rect));
CPTAssert(!r8.intersect(rect));
CPTAssert(r9.intersect(rect));
CPTAssert(r10.intersect(rect));
CPTAssert(r11.intersect(rect));
CPTAssert(!r12.intersect(rect));
}
static void fit3_read_block( PIA *pi, char * buf, int count )
{ int k, a, b, c, d;
switch (pi->mode) {
case 0: w2(0xc); w0(0x10); w2(0x8); w2(0xc);
for (k=0;k<count/2;k++) {
w2(0xd); a = r1();
w2(0xf); b = r1();
w2(0xc); c = r1();
w2(0xe); d = r1();
buf[2*k ] = j44(a,b);
buf[2*k+1] = j44(c,d);
}
w2(0xc);
break;
case 1: w2(0xc); w0(0x90); w2(0x8); w2(0xc);
w2(0xec); w2(0xee);
for (k=0;k<count/2;k++) {
w2(0xef); a = r0();
w2(0xee); b = r0();
buf[2*k ] = a;
buf[2*k+1] = b;
}
w2(0xec);
w2(0xc);
break;
case 2: w2(0xc); w0(0x90); w2(0x8); w2(0xc);
w2(0xec);
for (k=0;k<count;k++) buf[k] = r4();
w2(0xc);
break;
}
}
static void comm_read_block( PIA *pi, char * buf, int count )
{ int i, l, h;
switch (pi->mode) {
case 0: w0(0x48); P1;
for(i=0;i<count;i++) {
w0(0); w2(6); l = r1();
w0(0x80); h = r1(); w2(4);
buf[i] = j44(l,h);
}
break;
case 1: w0(0x68); P1; w0(0);
for(i=0;i<count;i++) {
w2(0x26); buf[i] = r0(); w2(0x24);
}
w2(4);
break;
case 2: w3(0x68); (void)r1(); w2(0x24);
for (i=0;i<count;i++) buf[i] = r4();
w2(4);
break;
case 3: w3(0x68); (void)r1(); w2(0x24);
for (i=0;i<count/2;i++) ((u16 *)buf)[i] = r4w();
w2(4);
break;
case 4: w3(0x68); (void)r1(); w2(0x24);
for (i=0;i<count/4;i++) ((u32 *)buf)[i] = r4l();
w2(4);
break;
}
}
void integration_rk4(listv2d& r, listv2d& v, listv2d& a, const listdouble& m, const double h, double ti) {
listv2d r1(ITEMS);
listv2d r2(ITEMS);
listv2d r3(ITEMS);
listv2d r4(ITEMS);
listv2d v2(ITEMS);
listv2d v3(ITEMS);
listv2d v4(ITEMS);
listv2d a2(ITEMS);
listv2d a3(ITEMS);
listv2d a4(ITEMS);
for (int i = 0; i < ITEMS; i++) {
r2[i] = r[i] + 0.5 * h * v[i];
v2[i] = v[i] + 0.5 * h * a[i];
}
calc_accel_multiple(r2, a2, m);
for (int i = 0; i < ITEMS; i++) {
r3[i] = r[i] + 0.5 * h * v2[i];
v3[i] = v[i] + 0.5 * h * a2[i];
}
calc_accel_multiple(r3, a3, m);
for (int i = 0; i < ITEMS; i++) {
r4[i] = r[i] + h * v3[i];
v4[i] = v[i] + h * a3[i];
}
calc_accel_multiple(r4, a4, m);
for (int i = 0; i < ITEMS; i++) {
r[i] = r[i] + h/6.0 * (v[i] + 2.0 * v2[i] + 2.0 * v3[i] + v4[i]);
v[i] = v[i] + h/6.0 * (a[i] + 2.0 * a2[i] + 2.0 * a3[i] + a4[i]);
}
}
int test2()
{
Node enclosingRect(0, 0, 40, 40);
MyRectangle r1(15, 30);
MyRectangle r2(20, 25);
MyRectangle r3(9, 7);
MyRectangle r4(20, 8);
MyRectangle r5(10, 10);
std::vector<MyRectangle> listRect;
listRect.push_back(r1);
listRect.push_back(r2);
listRect.push_back(r3);
listRect.push_back(r4);
listRect.push_back(r5);
Time tt;
for (int i = 0; i < 20000; i++)
{
auto w = rand() % 30 + 1;
auto h = rand() % 40 + 1;
MyRectangle a(w, h);
listRect.push_back(a);
}
std::cout << "Data creation time = " << tt.duration() << " ms" << std::endl;
Time t;
Node enclosingRect2(0,0,5000, 5000);
enclosingRect2.pack(listRect, enclosingRect2);
std::cout << "Execution time = " << t.duration() << " ms" << std::endl;
for (auto& a : listRect)
{
a.print();
}
return 0;
}
Dialog::Dialog(QWidget *parent) : QWidget(parent) {
ui.setupUi(this);
ui.pushButton->setText("&Exit");
connect(ui.pushButton, SIGNAL(clicked()), this, SLOT(myexit()));
connect(ui.r1, SIGNAL(clicked()), this, SLOT(r1()));
connect(ui.r2, SIGNAL(clicked()), this, SLOT(r2()));
connect(ui.r3, SIGNAL(clicked()), this, SLOT(r3()));
connect(ui.r4, SIGNAL(clicked()), this, SLOT(r4()));
connect(ui.betrag, SIGNAL(valueChanged(int)), this, SLOT(summechanged(int)));
connect(ui.tilgung, SIGNAL(valueChanged(int)), this, SLOT(tilgungchanged(int)));
connect(ui.zinsen, SIGNAL(valueChanged(double)), this, SLOT(zinssatzchanged(double)));
connect(ui.dateEdit, SIGNAL(dateChanged(QDate)), this, SLOT(berechne()));
connect(ui.restlaufzeit, SIGNAL(valueChanged(int)), this, SLOT(berechne_restlaufzeit(int)));
ui.r2->setChecked(true);
ui.radioTilgung->setChecked(true);
// restore settings from last session
ui.dateEdit->setDate(QDate::currentDate());
summechanged(55555); // in cents [euro]
tilgungchanged(5555); // in cents [euro]
zinssatzchanged(6.75); // prozent/100
r2(); // 4 == all 3 months
}
void *show_yes_no(void *t, void *msg, void *y, void *n)
{
p_ref r1(t),r2(msg),r3(y),r4(n);
y=eval(y);
n=eval(n);
put_title(lstring_value(eval(t)));
int x1=0,y1=0,x2=79,y2=25;
bar(x1,y1+1,x2,y2,176,0x01);
center_tbox(eval(msg),0x1f);
int key;
char *yes=lstring_value(y);
char *no=lstring_value(n);
set_cursor(0,25);
do
{
key=getch();
set_cursor(0,0);
} while (toupper(key)!=toupper(yes[0]) && toupper(key)!=toupper(no[0]));
cls();
if (toupper(key)==toupper(yes[0]))
return true_symbol;
else return NULL;
}
TEST(TypesTests, RegionConstructors) {
// 2D
Region r(10,10);
EXPECT_EQ(0, r.offset.x);
EXPECT_EQ(0, r.offset.y);
EXPECT_EQ(0, r.offset.z);
EXPECT_EQ(10, r.size.x);
EXPECT_EQ(10, r.size.y);
EXPECT_EQ(0, r.size.z);
Region r2(1,1, 10,10);
EXPECT_EQ(1, r2.offset.x);
EXPECT_EQ(1, r2.offset.y);
EXPECT_EQ(0, r2.offset.z);
EXPECT_EQ(10, r2.size.x);
EXPECT_EQ(10, r2.size.y);
EXPECT_EQ(0, r2.size.z);
// 3D
Region r3(10,10,10);
EXPECT_EQ(0, r3.offset.x);
EXPECT_EQ(0, r3.offset.y);
EXPECT_EQ(0, r3.offset.z);
EXPECT_EQ(10, r3.size.x);
EXPECT_EQ(10, r3.size.y);
EXPECT_EQ(10, r3.size.z);
Region r4(1,1,1, 10,10,10);
EXPECT_EQ(1, r4.offset.x);
EXPECT_EQ(1, r4.offset.y);
EXPECT_EQ(1, r4.offset.z);
EXPECT_EQ(10, r4.size.x);
EXPECT_EQ(10, r4.size.y);
EXPECT_EQ(10, r4.size.z);
}
void testSkipListNode()
{
SkipListNode head_bottom;
SkipListNode head_mid;
SkipListNode head_roof;
head_roof.down = &head_mid; head_mid.down = &head_bottom;
head_bottom.up = &head_mid; head_mid.up = &head_roof;
SkipListNode b1(1), b2(2), b3(3), b4(4);
SkipListNode m1(1), m2(2), m4(4);
SkipListNode r1(1), r4(4);
r1.down = &m1; m1.down = &b1;
b1.up = &m1; m1.up = &r1;
r4.down = &m4; m4.down = &b4;
b4.up = &m4; m4.up = &r4;
m2.down = &b2;
b2.up = &m2;
head_bottom.next = &b1; b1.next = &b2; b2.next = &b3; b3.next = &b4;
b4.prev = &b3; b3.prev = &b2; b2.prev = &b1; b1.prev = &head_bottom;
head_mid.next = &m1; m1.next = &m2; m2.next = &m4;
m4.prev = &m2; m2.prev = &m1; m1.prev = &head_mid;
head_roof.next = &r1; r1.next = &r4;
r4.prev = &r1; r1.prev = &head_roof;
std::cout<<head_roof;
std::cout<<head_mid;
std::cout<<head_bottom;
}
void CTinyCadDoc::InvalidateRect( CDRect r, BOOL erase, int grow, BOOL outline_only )
{
if (outline_only)
{
CDRect r1( r.left, r.top, r.right, r.top );
CDRect r2( r.right, r.top, r.right, r.bottom );
CDRect r3( r.right, r.bottom, r.left, r.bottom );
CDRect r4( r.left, r.bottom, r.left, r.top );
InvalidateRect( r1, erase, grow );
InvalidateRect( r2, erase, grow );
InvalidateRect( r3, erase, grow );
InvalidateRect( r4, erase, grow );
}
else
{
doc_invalidrect hint;
hint.r = r;
hint.grow = grow;
if (m_pParent)
{
m_pParent->UpdateAllViews( NULL, erase ? DOC_UPDATE_INVALIDRECTERASE : DOC_UPDATE_INVALIDRECT, &hint );
}
}
}
