void Constraint::ApplyImpulse()
{
if (bodyA != NULL && bodyA->mass < w_vars->UNMOVABLE_MASS)
{
bodyA->velocity = bodyA->velocity + Impulse * bodyA->iMass;
double iinrt1 = bodyA->iInert;
Vector3 imp3(Impulse.v1, Impulse.v2, 0);
Vector3 r3(rA.v1, rA.v2, 0);
r3 = r3.cross(imp3);
double ro1 = r3.v3;
bodyA->angle_vel += iinrt1 * ro1;
bodyA->angle_vel += iinrt1 * Torque;
}
if (bodyB != NULL && bodyB->mass < w_vars->UNMOVABLE_MASS)
{
bodyB->velocity = bodyB->velocity - Impulse * bodyB->iMass;
double iinrt2 = bodyB->iInert;
Vector3 imp3(Impulse.v1, Impulse.v2, 0);
Vector3 r3(rB.v1, rB.v2, 0);
r3 = r3.cross(imp3);
double ro2 = r3.v3;
bodyB->angle_vel -= iinrt2 * ro2;
bodyB->angle_vel -= iinrt2 * Torque;
}
}
TEST(SegmentTest, swaps)
{
{
RAJA::RangeSegment r1(0, 5);
RAJA::RangeSegment r2(1, 6);
RAJA::RangeSegment r3(r1);
RAJA::RangeSegment r4(r2);
std::swap(r1, r2);
ASSERT_EQ(r1, r4);
ASSERT_EQ(r2, r3);
}
{
RAJA::RangeStrideSegment r1(0, 5, 2);
RAJA::RangeStrideSegment r2(1, 6, 1);
RAJA::RangeStrideSegment r3(r1);
RAJA::RangeStrideSegment r4(r2);
std::swap(r1, r2);
ASSERT_EQ(r1, r4);
ASSERT_EQ(r2, r3);
}
{
RAJA::Index_type vals[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
RAJA::ListSegment r1(vals, 5, RAJA::Unowned);
RAJA::ListSegment r2(vals + 5, 5, RAJA::Unowned);
ASSERT_NE(r1, r2);
RAJA::ListSegment r3(r1);
RAJA::ListSegment r4(r2);
std::swap(r1, r2);
ASSERT_EQ(r1, r4);
ASSERT_EQ(r2, r3);
}
}
void Dirac_DomainWall_4D::
BprojCore_dag(double* f1,double* fN,const double* f) const{
// f1 = f5(0), fN = f5(N5_-1)
for(int c=0; c<NC_; ++c){
double fup_r = 0.5*(f[r0(c)] +f[r2(c)]);
double fup_i = 0.5*(f[i0(c)] +f[i2(c)]);
double fdn_r = 0.5*(f[r1(c)] +f[r3(c)]);
double fdn_i = 0.5*(f[i1(c)] +f[i3(c)]);
fN[r0(c)] = fup_r; fN[i0(c)] = fup_i;
fN[r1(c)] = fdn_r; fN[i1(c)] = fdn_i;
fN[r2(c)] = fup_r; fN[i2(c)] = fup_i;
fN[r3(c)] = fdn_r; fN[i3(c)] = fdn_i;
fup_r -= f[r2(c)]; //0.5*(f[r0(c)] -f[r2(c)])
fup_i -= f[i2(c)]; //0.5*(f[i0(c)] -f[i2(c)])
fdn_r -= f[r3(c)]; //0.5*(f[r1(c)] -f[r3(c)])
fdn_i -= f[i3(c)]; //0.5*(f[i1(c)] -f[i3(c)])
f1[r0(c)] = fup_r; f1[i0(c)] = fup_i;
f1[r1(c)] = fdn_r; f1[i1(c)] = fdn_i;
f1[r2(c)] =-fup_r; f1[i2(c)] =-fup_i;
f1[r3(c)] =-fdn_r; f1[i3(c)] =-fdn_i;
}
}
void GammaMatrix::isigma24core(double* w,const double* f)const{
for(int c=0; c<Ncol_; ++c){
w[r0(c)] = f[r3(c)]; w[i0(c)] = f[i3(c)];
w[r1(c)] =-f[r2(c)]; w[i1(c)] =-f[i2(c)];
w[r2(c)] = f[r1(c)]; w[i2(c)] = f[i1(c)];
w[r3(c)] =-f[r0(c)]; w[i3(c)] =-f[i0(c)];
}
}
void DiracWilsonLike::gamma5core(double* w,const double* f)const{
for(int c=0; c<N; ++c){
w[r0(c)] = f[r2(c)]; w[i0(c)] = f[i2(c)];
w[r1(c)] = f[r3(c)]; w[i1(c)] = f[i3(c)];
w[r2(c)] = f[r0(c)]; w[i2(c)] = f[i0(c)];
w[r3(c)] = f[r1(c)]; w[i3(c)] = f[i1(c)];
}
}
void GammaMatrix::projMcore(double* w,const double* f)const{
for(int c=0; c<Ncol_; ++c){
double fup_r = 0.5*(f[r0(c)] -f[r2(c)]);
double fup_i = 0.5*(f[i0(c)] -f[i2(c)]);
double fdn_r = 0.5*(f[r1(c)] -f[r3(c)]);
double fdn_i = 0.5*(f[i1(c)] -f[i3(c)]);
w[r0(c)] = fup_r; w[i0(c)] = fup_i;
w[r1(c)] = fdn_r; w[i1(c)] = fdn_i;
w[r2(c)] =-fup_r; w[i2(c)] =-fup_i;
w[r3(c)] =-fdn_r; w[i3(c)] =-fdn_i;
}
}
void DiracWilsonLike::projMcore(double* w,const double* f)const{
for(int c=0; c<N; ++c){
double fup_r = 0.5*(f[r0(c)] -f[r2(c)]);
double fup_i = 0.5*(f[i0(c)] -f[i2(c)]);
double fdn_r = 0.5*(f[r1(c)] -f[r3(c)]);
double fdn_i = 0.5*(f[i1(c)] -f[i3(c)]);
w[r0(c)] = fup_r; w[i0(c)] = fup_i;
w[r1(c)] = fdn_r; w[i1(c)] = fdn_i;
w[r2(c)] =-fup_r; w[i2(c)] =-fup_i;
w[r3(c)] =-fdn_r; w[i3(c)] =-fdn_i;
}
}
bool testClassBasics() {
bool passedTests=true;
RealNumber a=1,b=-22,c=5+5,d(1),e(2,1),f(-3),g(2,3);
if(passedTests)
passedTests = (a == 1);
if(passedTests)
passedTests = (b == -22);
if(passedTests)
passedTests = (c == 10);
if(passedTests)
passedTests = (d == 1);
if(passedTests)
passedTests = (e == 2);
if(passedTests)
passedTests = (f == -3);
if(passedTests)
passedTests = (g != 2 && g != 3);
RealNumber r1(20,30), r2(30,30), r3(30,20), r4(2,3), r5(3,2);
RealNumber r6 = r4;
if(passedTests)
passedTests = (r1 == r4);
if(passedTests)
passedTests = (r5 == r3);
if(passedTests)
passedTests = (r2 != r3);
if(passedTests)
passedTests = (r1 != r3);
if(passedTests)
passedTests = (r6 == r4);
return passedTests;
}
int main(void)
{
static const struct st3 a = {1, 2, 3, 4, 5, 6};
l1(100);
l2(100, 200);
l3(100, 200, 300);
l4(100, 200, 300, 400);
l5(100, 200, 300, 400, 500);
l6(100, 200, 300, 400, 500, 600);
l7(100, 200, 300, 400, 500, 600, 700);
l8(100, 200, 300, 400, 500, 600, 700, 800);
d1();
d2(43);
d3(100, 200);
d4(a);
d5('a', 43, a);
d6('a', 1);
c1(44);
c2(100, 'a', 3.4);
c3(200, 2.777, 'q');
c4(200, 1);
c5(1.1, 2.2);
c6(1.23, 45.6);
c7('z', 0x200);
a1('a');
a2(10);
a3(20);
a4(102030405060LL);
b1('a', 20);
b2(30, 'b');
b3(10, 20, 30, 40, 50, 60);
s1(sx);
s1p(&sx);
s2(sy);
s3(sz);
s4(sq);
s5(sa);
s6(sb);
r1();
r3();
r4();
q1(200, sx);
q2(300, 't', sx);
q3(400, 410, sy);
q4(500, 510, sq);
q5(600, 610, 'z', 'q', sq);
real1("fresh air");
real2();
return 0;
}
TVector3<float> rotateAround( const TVector3<float>& v,
const TVector3<float>& axis,
float angle )
{
float one = 1.0f;
if ( Math::notZero( angle ) )
{
float sangle = sin( Math::Pi * angle / 180.0f );
float cangle = cos( Math::Pi * angle / 180.0f );
float xangle = one - cangle; // "1 minus cos angle"
TVector3<float> u = normalized( axis );
TVector3<float> r1( u.mX * u.mX + cangle * ( one - u.mX * u.mX ),
u.mX * u.mY * xangle - sangle * u.mZ,
u.mY * u.mZ * xangle + sangle * u.mY );
TVector3<float> r2( u.mX * u.mY * xangle + sangle * u.mZ,
u.mY * u.mY + cangle * ( one - u.mY * u.mY ),
u.mY * u.mZ * xangle - sangle * u.mX );
TVector3<float> r3( u.mX * u.mZ * xangle - sangle * u.mY,
u.mY * u.mZ * xangle + sangle * u.mX,
u.mZ * u.mZ + cangle * ( one - u.mZ * u.mZ ) );
return TVector3<float>( dot( v, r1 ),
dot( v, r2 ),
dot( v, r3 ) );
}
else
{
return v;
}
}
int main()
{
// initialize grid. params are read from input file
GRID grid;
// initialize a result object on grid
Result result(&grid);
// fill in Delta by initializing it to semi-circle
InitDelta(DOStypes::SemiCircle, grid.get_N(), 0.2, 0.0, 0.01, 0.5, result.omega, result.Delta);
result.mu = 0.1;
result.n = 0.5;
result.mu0 = 0.3;
//make a copy
Result r2(result);
//r2.CopyFrom(&result);
r2.mu = 0.2;
r2.Delta[1000] = 7;
result.PrintResult("Result.dat");
r2.PrintResult("Result.dat.c");
Result r3(&grid);
// this way mu, n and mu0 are not read
r3.ReadFromFile("Result.dat.c");
r3.n = 0.3;
r3.PrintResult("Result.dat.cc");
return 0;
}
/** An sample for taylor expansion of logdet(X). */
void taylorSample() {
std::string ans;
char rowChar[5];
int rowTmp = ROW;
sprintf(rowChar, "%d", rowTmp);
std::string row = rowChar;
// Initialize the matrices.
symbolic_matrix_type X("X", ROW, COL);
symbolic_matrix_type X0("X0", ROW, COL);
symbolic_matrix_type Delta("(X-X0)", ROW, COL);
AMD::SymbolicScalarMatlab a2("1/2!");
AMD::SymbolicScalarMatlab a3("1/3!");
SymbolicSMFunc r2(a2,ROW,COL);
SymbolicSMFunc r3(a3,ROW, COL);
// Initialize MatrixMatrixFunction.
SymbolicMMFunc fX(X, false);
SymbolicMMFunc fX0(X0, false);
SymbolicMMFunc fDelta(Delta, true);
// Compute Taylor series iteratively.
SymbolicSMFunc f0 = logdet(fX0);
SymbolicSMFunc f1 = trace(fDelta * transpose(*f0.derivativeFuncVal));
SymbolicSMFunc f2 = trace(fDelta * transpose(*f1.derivativeFuncVal));
SymbolicSMFunc f3 = trace(fDelta * transpose(*f2.derivativeFuncVal));
// Taylor Expansion.
SymbolicSMFunc func = f0 + f1 + r2*f2 + r3*f3;
std::cout<<"The first 4 terms of Taylor Expansion for logdet(X) around X0 is:";
std::cout << std::endl;
std::cout << func.functionVal.getString() << std::endl;
}
void CDrawArea::SelfTest()
{
#ifdef _DEBUG
CDrawArea a,b,c;
CRect<int> rMax(0,0,640,400);
CRect<int> r1(0,0,100,100);
CRect<int> r2(0,0,500,300);
CRect<int> r3(200,200,300,300);
CRect<int> rTooBig(0,0,1000,1000);
ASSERT(a.Size()==0);
a.Combine(r1);
ASSERT(a.Size()==1);
ASSERT(a.Rect(0,rMax).Equals(r1));
a.Combine(r3);
ASSERT(a.Size()==2);
ASSERT(a.Rect(0,rMax).Equals(r1));
ASSERT(a.Rect(1,rMax).Equals(r3));
a.Combine(r2);
ASSERT(a.Size()==1);
ASSERT(a.Rect(0,rMax).Equals(r2));
a.Combine(rTooBig);
ASSERT(a.Size()==1);
#endif
}
void tst_QPicture::boundingRect()
{
QPicture p1;
// default value
QVERIFY( !p1.boundingRect().isValid() );
QRect r1( 20, 30, 5, 15 );
p1.setBoundingRect( r1 );
QCOMPARE( p1.boundingRect(), r1 );
p1.setBoundingRect(QRect());
QPainter pt( &p1 );
pt.drawLine( 10, 20, 110, 80 );
pt.end();
// assignment and copy constructor
QRect r2( 10, 20, 100, 60 );
QCOMPARE( p1.boundingRect(), r2 );
QPicture p2( p1 );
QCOMPARE( p1.boundingRect(), r2 );
QPicture p3;
p3 = p1;
QCOMPARE( p1.boundingRect(), r2 );
{
QPicture p4;
QPainter p(&p4);
p.drawLine(0, 0, 5, 0);
p.drawLine(0, 0, 0, 5);
p.end();
QRect r3(0, 0, 5, 5);
QCOMPARE(p4.boundingRect(), r3);
}
}
template<typename MatrixType> void test_reference(const MatrixType& m) {
typedef typename MatrixType::Scalar Scalar;
enum { Flag = MatrixType::IsRowMajor ? Eigen::RowMajor : Eigen::ColMajor};
enum { TransposeFlag = !MatrixType::IsRowMajor ? Eigen::RowMajor : Eigen::ColMajor};
typename MatrixType::Index rows = m.rows(), cols=m.cols();
typedef Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Flag > MatrixX;
typedef Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, TransposeFlag> MatrixXT;
// Dynamic reference:
typedef Eigen::Ref<const MatrixX > Ref;
typedef Eigen::Ref<const MatrixXT > RefT;
Ref r1(m);
Ref r2(m.block(rows/3, cols/4, rows/2, cols/2));
RefT r3(m.transpose());
RefT r4(m.topLeftCorner(rows/2, cols/2).transpose());
VERIFY_RAISES_ASSERT(RefT r5(m));
VERIFY_RAISES_ASSERT(Ref r6(m.transpose()));
VERIFY_RAISES_ASSERT(Ref r7(Scalar(2) * m));
// Copy constructors shall also never malloc
Ref r8 = r1;
RefT r9 = r3;
// Initializing from a compatible Ref shall also never malloc
Eigen::Ref<const MatrixX, Unaligned, Stride<Dynamic, Dynamic> > r10=r8, r11=m;
// Initializing from an incompatible Ref will malloc:
typedef Eigen::Ref<const MatrixX, Aligned> RefAligned;
VERIFY_RAISES_ASSERT(RefAligned r12=r10);
VERIFY_RAISES_ASSERT(Ref r13=r10); // r10 has more dynamic strides
}
int test()
{
//Test it correctly or not
MyRectangle enclosingRect(40, 40);
MyRectangle r1(15, 30);
MyRectangle r2(20, 25);
MyRectangle r5(10, 10);
MyRectangle r4(20, 8);
MyRectangle r3(9, 7);
std::vector<MyRectangle> listRect;
listRect.push_back(r1);
listRect.push_back(r2);
listRect.push_back(r3);
listRect.push_back(r4);
listRect.push_back(r5);
Node node(0, 0, 40, 40);
node.packWithNoPreSort(listRect, node);
for (auto rect : listRect)
{
rect.print();
}
std:cout << "here is packing alogorthim in codeproject\n";
PackingAlogorithm pa;
pa.pack(listRect, enclosingRect);
for (auto rect : listRect)
{
rect.print();
}
}
Foam::cylindricalCS Foam::arcEdge::calcAngle()
{
vector a = p2_ - p1_;
vector b = p3_ - p1_;
// find centre of arcEdge
scalar asqr = a & a;
scalar bsqr = b & b;
scalar adotb = a & b;
scalar denom = asqr*bsqr - adotb*adotb;
if (mag(denom) < VSMALL)
{
FatalErrorInFunction
<< denom
<< abort(FatalError);
}
scalar fact = 0.5*(bsqr - adotb)/denom;
point centre = 0.5*a + fact*((a ^ b) ^ a);
centre += p1_;
// find position vectors w.r.t. the arcEdge centre
vector r1(p1_ - centre);
vector r2(p2_ - centre);
vector r3(p3_ - centre);
// find angles
angle_ = radToDeg(acos((r3 & r1)/(mag(r3) * mag(r1))));
// check if the vectors define an exterior or an interior arcEdge
if (((r1 ^ r2) & (r1 ^ r3)) < 0.0)
{
angle_ = 360.0 - angle_;
}
vector tempAxis;
if (angle_ <= 180.0)
{
tempAxis = r1 ^ r3;
if (mag(tempAxis)/(mag(r1)*mag(r3)) < 0.001)
{
tempAxis = r1 ^ r2;
}
}
else
{
tempAxis = r3 ^ r1;
}
radius_ = mag(r3);
// set up and return the local coordinate system
return cylindricalCS("arcEdgeCS", centre, tempAxis, r1);
}
DEF_TEST(Data, reporter) {
const char* str = "We the people, in order to form a more perfect union.";
const int N = 10;
SkAutoTUnref<SkData> r0(SkData::NewEmpty());
SkAutoTUnref<SkData> r1(SkData::NewWithCopy(str, strlen(str)));
SkAutoTUnref<SkData> r2(SkData::NewWithProc(new int[N], N*sizeof(int),
delete_int_proc, gGlobal));
SkAutoTUnref<SkData> r3(SkData::NewSubset(r1, 7, 6));
assert_len(reporter, r0, 0);
assert_len(reporter, r1, strlen(str));
assert_len(reporter, r2, N * sizeof(int));
assert_len(reporter, r3, 6);
assert_data(reporter, r1, str, strlen(str));
assert_data(reporter, r3, "people", 6);
SkData* tmp = SkData::NewSubset(r1, strlen(str), 10);
assert_len(reporter, tmp, 0);
tmp->unref();
tmp = SkData::NewSubset(r1, 0, 0);
assert_len(reporter, tmp, 0);
tmp->unref();
test_cstring(reporter);
test_files(reporter);
}
int main()
try {
// constructors
Rational r1;
Rational r2(5);
Rational r3(7,3);
cout << "r1: " << r1 << endl
<< "r2: " << r2 << endl
<< "r3: " << r3 << endl;
// operators
cout << "5/3 + 7/2 = " << Rational(5,3) + Rational(7/2) <<
" = " << (Rational(5,3) + Rational(7/2)).conv_double() << endl;
cout << "8/5 - 40/7 = " << Rational(8,5) - Rational(40,7) <<
" = " << (Rational(8,5) - Rational(40,7)).conv_double() << endl;
cout << "10/11 * 17/18 = " << Rational(10,11) * Rational(17,18) <<
" = " << (Rational(10,11) * Rational(17,18)).conv_double() << endl;
//cout << "5 / (0/3) = " << Rational(5) / Rational(0,3) << endl;
cout << "(5/7) / (1/3) = " << Rational(5,7) / Rational(1,3) <<
" = " << (Rational(5,7) / Rational(1,3)).conv_double() << endl;
if (r1 == Rational(0,1)) cout << "r1 == 0/1" << endl;
if (Rational(1,2) == Rational(2,4)) cout << "1/2 == 2/4" << endl;
if (r2 != r2) cout << "r2 != r2" << endl;
cout << r3 << " = " << r3.conv_double() << endl;
}
catch (exception& e) {
cerr << "exception: " << e.what() << endl;
}
catch (...) {
cerr << "exception" << endl;
}
TheTest & test_loadstore_fp16()
{
#if CV_FP16 && CV_SIMD128
AlignedData<R> data;
AlignedData<R> out;
if(1 /* checkHardwareSupport(CV_CPU_FP16) */ )
{
// check if addresses are aligned and unaligned respectively
EXPECT_EQ((size_t)0, (size_t)&data.a.d % 16);
EXPECT_NE((size_t)0, (size_t)&data.u.d % 16);
EXPECT_EQ((size_t)0, (size_t)&out.a.d % 16);
EXPECT_NE((size_t)0, (size_t)&out.u.d % 16);
// check some initialization methods
R r1 = data.u;
R r2 = v_load_f16(data.a.d);
R r3(r2);
EXPECT_EQ(data.u[0], r1.get0());
EXPECT_EQ(data.a[0], r2.get0());
EXPECT_EQ(data.a[0], r3.get0());
// check some store methods
out.a.clear();
v_store_f16(out.a.d, r1);
EXPECT_EQ(data.a, out.a);
}
return *this;
#endif
}
int main(){
char in[2000];
int i;
scanf("%d",&n);
while(scanf("%s",in)!=EOF){
for(i=0;i<1100;i++){
c1[i]=c2[i]=0;
in[i]=0;
}
p1[1]=0;
for(i=2;i<=strlen(in)+1;i++){
p1[i]=p1[i-1]+(in[i-2]=='1'?1:0)*(i-1);
c1[i]=c1[i-1]+(in[i-2]=='1'?1:0);
}
p2[strlen(in)]=0;
for(i=strlen(in)-1;i>=0;i--){
p2[i]=p2[i+1]+(in[i]=='1'?1:0)*(i+1);
c2[i]=c2[i+1]+(in[i]=='1'?1:0);
}
if((p2[0]%(n+1))==0&&strlen(in)==n);
else if(strlen(in)==n)r1(in);
else if(strlen(in)==n-1)r2(in);
else if(strlen(in)==n+1)r3(in);
printf("%s\n",in);
}
}
double Solver::findLowerBound3(const vector<double> &lagSolution, vector<double> &sol) {
sol.assign(getNVariables(), 0);
for (int i = 0; i < m_problem->getNTasks(); i++)
for (int j = 0; j < m_problem->getNAgents(); j++)
sol[getX(i, j)] = lagSolution[getX(i, j)];
if (isFeasable(lagSolution)) {
return evaluate(lagSolution);
}
vector<double> r2(m_problem->getNTasks());
vector<double> r3(m_problem->getNAgents());
r2.assign(m_problem->getNTasks(), 0);
r3.assign(m_problem->getNAgents(), 0);
int m = m_problem->getNTasks();
int n = m_problem->getNAgents();
//Calculando custos da restrição 1 e 2
for (int i = 0; i < m; i++) //para cada tarefa i
for (int j = 0; j < n; j++) { // para cada agente j
r2[i] = r2[i] + sol[getX(i, j)];
r3[j] += sol[getX(i, j)] * m_problem->getLoad(i, j);
}
for (int j = 0; j < r3.size(); j++) {
if (m_problem->getCapacity(j) < r3[j])
while (m_problem->getCapacity(j) < r3[j]) {
int menor = -1;
for (int i = 0; i < m; i++)
if (sol[getX(i, j)] == 1)
menor = menor == -1 ? i : m_problem->getGain(i, j) < m_problem->getGain(menor, j) ? i : menor;
sol[getX(menor, j)] = 0;
r2[menor]--;
r3[j] -= m_problem->getLoad(menor, j);
}
}
for (int i = 0; i < m; i++) {
int melhor = -1;
if (r2[i] == 0) {
for (int j = 0; j < n; j++)
melhor = (m_problem->getGain(i, j) > m_problem->getGain(i, melhor)) && (r3[j] + m_problem->getLoad(i, j) <= m_problem->getCapacity(j)) ? j : melhor;
if (melhor != -1) {
sol[getX(i, melhor)] = 1;
r2[i] += 1;
r3[melhor] += m_problem->getLoad(i, melhor);
}
}
}
return evaluate(sol);
}
void DW5dMatrix::BprojCore(double* f,const double* f1,const double* fN)const{
for(int c=0; c<Ncol_; ++c){
double fupNr = 0.5*(fN[r0(c)] +fN[r2(c)]);
double fupNi = 0.5*(fN[i0(c)] +fN[i2(c)]);
double fdnNr = 0.5*(fN[r1(c)] +fN[r3(c)]);
double fdnNi = 0.5*(fN[i1(c)] +fN[i3(c)]);
double fup1r = 0.5*(f1[r0(c)] -f1[r2(c)]);
double fup1i = 0.5*(f1[i0(c)] -f1[i2(c)]);
double fdn1r = 0.5*(f1[r1(c)] -f1[r3(c)]);
double fdn1i = 0.5*(f1[i1(c)] -f1[i3(c)]);
f[r0(c)] = fupNr +fup1r; f[i0(c)] = fupNi +fup1i;
f[r1(c)] = fdnNr +fdn1r; f[i1(c)] = fdnNi +fdn1i;
f[r2(c)] = fupNr -fup1r; f[i2(c)] = fupNi -fup1i;
f[r3(c)] = fdnNr -fdn1r; f[i3(c)] = fdnNi -fdn1i;
}
}
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();
}
Foam::cylindricalCS Foam::arcEdge::calcAngle()
{
vector a = p2_ - p1_;
vector b = p3_ - p1_;
// find centre of arcEdge
scalar asqr = a & a;
scalar bsqr = b & b;
scalar adotb = a & b;
scalar denom = asqr*bsqr - adotb*adotb;
if (mag(denom) < VSMALL)
{
FatalErrorIn("cylindricalCS arcEdge::calcAngle()")
<< "Invalid arc definition - are the points co-linear? Denom ="
<< denom
<< abort(FatalError);
}
scalar fact = 0.5*(bsqr - adotb)/denom;
vector centre = 0.5*a + fact*((a ^ b) ^ a);
centre += p1_;
// find position vectors w.r.t. the arcEdge centre
vector r1(p1_ - centre);
vector r2(p2_ - centre);
vector r3(p3_ - centre);
// find angles
scalar tmp = (r3&r1)/(mag(r3)*mag(r1));
angle_ = acos(tmp)*180.0/mathematicalConstant::pi;
// check if the vectors define an exterior or an interior arcEdge
if (((r1 ^ r2)&(r1 ^ r3)) < 0.0) angle_ = 360 - angle_;
vector tempAxis(0.0,0.0,0.0);
if (angle_ <= 180.0)
{
tempAxis = r1 ^ r3;
if (mag(tempAxis)/(mag(r1)*mag(r3)) < 0.001) tempAxis = r1 ^ r2;
}
else
{
tempAxis = r3 ^ r1;
}
radius_ = mag(r3);
// set up and return the local coordinate system
return cylindricalCS("tmpCS", centre, tempAxis, r1);
}
void
JX3DWidget::ContinueDrag
(
const JPoint& pt
)
{
if (itsDragType == kRotateDrag)
{
const JVector delta(3, - pt.x + itsStartPt.x, pt.y - itsStartPt.y, 0.0);
const JVector& o = itsCamera->GetAttentionPt();
JVector v = itsStartPos - o;
const JFloat r = v.GetLength();
const JFloat lat = asin(v.GetElement(3) / r);
const JFloat lon = atan2(v.GetElement(2), v.GetElement(1));
// direction of drag relative to screen x-axis
const JFloat alpha = atan2(delta.GetElement(2), delta.GetElement(1));
// delta along the sphere in drag direction
const JFloat phi = delta.GetLength() / (r * 50);
JVector p(3, r*cos(phi), r*sin(phi), 0.0);
// inverse: rotate around z-axis for partial alignment of x-axis
JMatrix r1(3, 3);
r1.SetElements(
cos(lon), -sin(lon), 0.0,
sin(lon), cos(lon), 0.0,
0.0, 0.0, 1.0);
// inverse: rotate around y-axis for complete alignment of x-axis towards viewer
JMatrix r2(3, 3);
r2.SetElements(
cos(lat), 0.0, -sin(lat),
0.0, 1.0, 0.0,
sin(lat), 0.0, cos(lat));
// inverse: rotate around x-axis to align y-axis with drag direction
JMatrix r3(3, 3);
r3.SetElements(
1.0, 0.0, 0.0,
0.0, cos(alpha), -sin(alpha),
0.0, sin(alpha), cos(alpha));
// transform delta long the sphere to our coordinate system
p = (r1 * r2 * r3 * p).GetColVector(1);
itsCamera->SetPosition(p + o);
}
}
void Dirac_DomainWall_4D::
BprojCore(double* f,const double* f1,const double* fN)const{
for(int c=0; c<NC_; ++c){
double fupNr = 0.5*(fN[r0(c)] +fN[r2(c)]);
double fupNi = 0.5*(fN[i0(c)] +fN[i2(c)]);
double fdnNr = 0.5*(fN[r1(c)] +fN[r3(c)]);
double fdnNi = 0.5*(fN[i1(c)] +fN[i3(c)]);
double fup1r = 0.5*(f1[r0(c)] -f1[r2(c)]);
double fup1i = 0.5*(f1[i0(c)] -f1[i2(c)]);
double fdn1r = 0.5*(f1[r1(c)] -f1[r3(c)]);
double fdn1i = 0.5*(f1[i1(c)] -f1[i3(c)]);
f[r0(c)] = fupNr +fup1r; f[i0(c)] = fupNi +fup1i;
f[r1(c)] = fdnNr +fdn1r; f[i1(c)] = fdnNi +fdn1i;
f[r2(c)] = fupNr -fup1r; f[i2(c)] = fupNi -fup1i;
f[r3(c)] = fdnNr -fdn1r; f[i3(c)] = fdnNi -fdn1i;
}
}
/* ************************************************************************* */
Point3 Rot3::column(int index) const{
if(index == 3)
return r3();
else if(index == 2)
return r2();
else if(index == 1)
return r1(); // default returns r1
else
throw invalid_argument("Argument to Rot3::column must be 1, 2, or 3");
}
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
}
