Surface::Surface(const QString &equation, qreal a, QObject *parent) : QObject(parent), privateMemberLock(QReadWriteLock::Recursive) { construct(); setEquation(equation); setA(a); }
void control::event2() { setA(false); setC(true); qDebug() << "Plastic Bottling Size Reached"; qDebug() << "Molding Bottle"; QTimer::singleShot(500, this, SLOT(event3())); }
int main() { double dr = 1.0 / (double) R; double dt = 0.0001; double mu = 0.5 * dt / (dr*dr); int i = 0; double U[(R+1)*(R+1)]; double b[(R+1)*(R+1)]; double du[R]; double dc[R+1]; double dl[R]; printf("mu = %.5lf\n", mu); setInitialCondition(U, (R+1), (R+1), dr); setA(du, dc, dl, (R+1), (R+1), mu); dumpMatrix(U, (R+1), (R+1), dr, 0); while (i++ < 5) { diffuse(U, b, (R+1), (R+1), du, dc, dl, mu); dumpMatrix(U, (R+1), (R+1), dr, i); } }
// Set from Botan representation void BotanEDPublicKey::setFromBotan(const Botan::Public_Key* inEDKEY) { Botan::OID oid; std::vector<uint8_t> pub; for (;;) { const Botan::Curve25519_PublicKey* x25519 = dynamic_cast<const Botan::Curve25519_PublicKey*>(inEDKEY); if (x25519) { oid = x25519_oid; pub = x25519->public_value(); break; } const Botan::Ed25519_PublicKey* ed25519 = dynamic_cast<const Botan::Ed25519_PublicKey*>(inEDKEY); if (ed25519) { oid = ed25519_oid; pub = ed25519->get_public_key(); break; } return; } ByteString inEC = BotanUtil::oid2ByteString(oid); setEC(inEC); ByteString inA; inA.resize(pub.size()); memcpy(&inA[0], &pub[0], pub.size()); setA(DERUTIL::raw2Octet(inA)); }
//------------------------------------------------------------------------------ // Slot functions //------------------------------------------------------------------------------ bool EarthModel::setSlotA(const Distance* const msg) { bool ok = false; if (msg != nullptr) { ok = setA( Meters::convertStatic( *msg ) ); } return ok; }
bool EarthModel::setSlotA(const Number* const msg) { bool ok = false; if (msg != nullptr) { ok = setA( msg->getDouble() ); } return ok; }
Quaternion::Quaternion() : Vector(4) { setA(1.0f); setB(0.0f); setC(0.0f); setD(0.0f); }
TransformationMatrix::TransformationMatrix(const CGAffineTransform& t) { setA(t.a); setB(t.b); setC(t.c); setD(t.d); setE(t.tx); setF(t.ty); }
Quaternion::Quaternion(float a, float b, float c, float d) : Vector(4) { setA(a); setB(b); setC(c); setD(d); }
int main(void) { if (b == 0) setB(); if (a == 0) setA(); assert(a == 1); return 0; }
Quaternion::Quaternion(const Dcm &dcm) : Vector(4) { setA(0.5f * sqrtf(1 + dcm(0, 0) + dcm(1, 1) + dcm(2, 2))); setB((dcm(2, 1) - dcm(1, 2)) / (4 * getA())); setC((dcm(0, 2) - dcm(2, 0)) / (4 * getA())); setD((dcm(1, 0) - dcm(0, 1)) / (4 * getA())); }
MEvent::MEvent(unsigned tick, int port, int channel, const Event& e, MidiTrack* trk) { m_track = trk; m_source = SystemSource; setChannel(channel); setTime(tick); setPort(port); setLoopNum(0); switch (e.type()) { case Note: setType(ME_NOTEON); setA(e.dataA()); setB(e.dataB()); break; case Controller: setType(ME_CONTROLLER); setA(e.dataA()); // controller number setB(e.dataB()); // controller value break; case PAfter: setType(ME_POLYAFTER); setA(e.dataA()); setB(e.dataB()); break; case CAfter: setType(ME_AFTERTOUCH); setA(e.dataA()); setB(0); break; case Sysex: setType(ME_SYSEX); setData(e.eventData()); break; default: printf("MEvent::MEvent(): event type %d not implemented\n", type()); break; } }
void Triangle::configure(const std::string& parameters) { if (parameters.empty()) return; std::vector<std::string> values = Op::split(parameters, " "); std::size_t required = 3; if (values.size() < required) { std::ostringstream ex; ex << "[configuration error] term <" << className() << ">" << " requires <" << required << "> parameters"; throw fl::Exception(ex.str(), FL_AT); } setA(Op::toScalar(values.at(0))); setB(Op::toScalar(values.at(1))); setC(Op::toScalar(values.at(2))); }
Quaternion::Quaternion(const Dcm &dcm) : Vector(4) { // avoiding singularities by not using // division equations setA(0.5 * sqrt(1.0 + double(dcm(0, 0) + dcm(1, 1) + dcm(2, 2)))); setB(0.5 * sqrt(1.0 + double(dcm(0, 0) - dcm(1, 1) - dcm(2, 2)))); setC(0.5 * sqrt(1.0 + double(-dcm(0, 0) + dcm(1, 1) - dcm(2, 2)))); setD(0.5 * sqrt(1.0 + double(-dcm(0, 0) - dcm(1, 1) + dcm(2, 2)))); }
/* * What is the mean of your score if N=SOMETHING * What is the standard deviation of your score if N=SOMETHING */ void play_optimize(int nTrial){ const int nT = nTrial; const int original_valA = cards[0]; setA(1); T totalScore =0; for(; nTrial > 0 ; nTrial--){ //drawn cards using A=1 std::vector<int> trialCard; T point_one=0; T numC_one = 0; T num_aces=0; for(; point_one < N ; numC_one++){ uint c = getCard(); point_one+=c; trialCard.push_back(c); if(c==1) num_aces++; } //print(trialCard.begin(),trialCard.end()); //printf("\tnum_extractions %i, num_aces = %i, point %i\n",numC_one,num_aces,point_one); int bestVal = computeBestScore(trialCard,0,0); T trialScore = (bestVal-N); data.push_back(trialScore); totalScore+=trialScore; //printf("BEST VALUE %i score = %i \n",bestVal,trialScore); //printf("%i,",trialScore); }//for trials mean = (double)totalScore/(double)nT; stdev= std::sqrt(computeVariance(data)); printf("\tN=%i , mean = %.10f , stdev = %.10f\n",N,mean,stdev); setA(original_valA); }
// 0x53 // Increment Register A void R34HC22::incrementRegisterA(int address){ if((address + 1) < getMemSize()){ // increare the value of A setA(getA() + 1); // move the program counter to the next byte setProgCounter(address + 1); executeFromLocation(address + 1); cout << complete_mess << endl; } else { cerr << error_mess << endl; haltOpcode(); } }
int main(void) { while(c) { if (b == 0) goto L; if (check()) { c = 0; L: setA(); setB(); } } return 0; }
Quaternion::Quaternion(const EulerAngles &euler) : Vector(4) { float cosPhi_2 = cosf(euler.getPhi() / 2.0f); float cosTheta_2 = cosf(euler.getTheta() / 2.0f); float cosPsi_2 = cosf(euler.getPsi() / 2.0f); float sinPhi_2 = sinf(euler.getPhi() / 2.0f); float sinTheta_2 = sinf(euler.getTheta() / 2.0f); float sinPsi_2 = sinf(euler.getPsi() / 2.0f); setA(cosPhi_2 * cosTheta_2 * cosPsi_2 + sinPhi_2 * sinTheta_2 * sinPsi_2); setB(sinPhi_2 * cosTheta_2 * cosPsi_2 - cosPhi_2 * sinTheta_2 * sinPsi_2); setC(cosPhi_2 * sinTheta_2 * cosPsi_2 + sinPhi_2 * cosTheta_2 * sinPsi_2); setD(cosPhi_2 * cosTheta_2 * sinPsi_2 + sinPhi_2 * sinTheta_2 * cosPsi_2); }
Quaternion::Quaternion(const EulerAngles &euler) : Vector(4) { double cosPhi_2 = cos(double(euler.getPhi()) / 2.0); double sinPhi_2 = sin(double(euler.getPhi()) / 2.0); double cosTheta_2 = cos(double(euler.getTheta()) / 2.0); double sinTheta_2 = sin(double(euler.getTheta()) / 2.0); double cosPsi_2 = cos(double(euler.getPsi()) / 2.0); double sinPsi_2 = sin(double(euler.getPsi()) / 2.0); setA(cosPhi_2 * cosTheta_2 * cosPsi_2 + sinPhi_2 * sinTheta_2 * sinPsi_2); setB(sinPhi_2 * cosTheta_2 * cosPsi_2 - cosPhi_2 * sinTheta_2 * sinPsi_2); setC(cosPhi_2 * sinTheta_2 * cosPsi_2 + sinPhi_2 * cosTheta_2 * sinPsi_2); setD(cosPhi_2 * cosTheta_2 * sinPsi_2 - sinPhi_2 * sinTheta_2 * cosPsi_2); }
void TGAImage::initFirstLOD( unsigned char* srcData) { lodData[0] = new unsigned char[ getLODwidth(0) * getLODheight(0) * BPP ] ; for( int i = 0 ; i < getLODwidth(0) ; i++ ) for( int j = 0 ; j < getLODheight(0) ; j++ ) { unsigned char r, g, b, a ; if( srcData ) getRGBA( srcData, i, getLODheight(0) - 1 - j, r, g, b, a ) ; else r = g = b = a = 0 ; setR( 0, i, j, r ) ; setG( 0, i, j, g ) ; setB( 0, i, j, b ) ; setA( 0, i, j, a ) ; } goodLOD = 0 ; }
void TGAImage::generateLOD( int lod ) { int dstW = getLODwidth(lod) ; int dstH = getLODheight(lod); if( lodData[lod] == NULL ) lodData[lod] = new unsigned char[ dstW * dstH * BPP ] ; int s = getLODwidth(0) / dstW ; int t = getLODheight(0) / dstH ; for( int i = 0 ; i < dstW ; i++ ) for( int j = 0 ; j < dstH ; j++ ) { int r = 0, g = 0, b = 0, a = 0 ; for( int k = 0 ; k < s ; k++ ) for( int l = 0 ; l < t ; l++ ) { r += getR( 0, i * s + k, j * t + l ) ; g += getG( 0, i * s + k, j * t + l ) ; b += getB( 0, i * s + k, j * t + l ) ; a += getA( 0, i * s + k, j * t + l ) ; } r /= s * t ; g /= s * t ; b /= s * t ; a /= s * t ; setR( lod, i, j, r ) ; setG( lod, i, j, g ) ; setB( lod, i, j, b ) ; setA( lod, i, j, a ) ; } goodLOD = lod ; }
// 0x37 // Load A with Value void R34HC22::loadRegisterWithValue(int address, string r) { if((address + 2) < getMemSize()) { if(r.compare("A") == 0) { // load value from the first byte after the opcode to A setA(getMemoryValueAtLocation(address + 1)); } else if(r.compare("B") == 0) { // load value from the first byte after the opcode to B setB(getMemoryValueAtLocation(address + 1)); } // set the program counter the the second byte after opcode setProgCounter(address + 2); executeFromLocation(address + 2); cout << complete_mess << endl; } else { cerr << error_mess << endl; haltOpcode(); } }
Complex& Complex::operator=(const Complex &other){ setA(other.a); setB(other.b); }
void control::event1() { setA(true); qDebug() << "New Bottle"; qDebug() << "Bottling Started"; QTimer::singleShot(5000, this, SLOT(event2())); }
void DirectionalAtom::rotateBy(const RotMat3x3d& m) { setA(m *getA()); }
/* * s e t u p A u x i l i a r y Q P */ returnValue SQProblem::setupAuxiliaryQP ( SymmetricMatrix *H_new, Matrix *A_new, const real_t *lb_new, const real_t *ub_new, const real_t *lbA_new, const real_t *ubA_new ) { int i; int nV = getNV( ); int nC = getNC( ); returnValue returnvalue; if ( ( getStatus( ) == QPS_NOTINITIALISED ) || ( getStatus( ) == QPS_PREPARINGAUXILIARYQP ) || ( getStatus( ) == QPS_PERFORMINGHOMOTOPY ) ) { return THROWERROR( RET_UPDATEMATRICES_FAILED_AS_QP_NOT_SOLVED ); } status = QPS_PREPARINGAUXILIARYQP; /* I) SETUP NEW QP MATRICES AND VECTORS: */ /* 1) Shift constraints' bounds vectors by (A_new - A)'*x_opt to ensure * that old optimal solution remains feasible for new QP data. */ /* Firstly, shift by -A'*x_opt and ... */ if ( nC > 0 ) { if ( A_new == 0 ) return THROWERROR( RET_INVALID_ARGUMENTS ); for ( i=0; i<nC; ++i ) { lbA[i] = -Ax_l[i]; ubA[i] = Ax_u[i]; } /* Set constraint matrix as well as ... */ setA( A_new ); /* ... secondly, shift by +A_new'*x_opt. */ for ( i=0; i<nC; ++i ) { lbA[i] += Ax[i]; ubA[i] += Ax[i]; } /* update constraint products. */ for ( i=0; i<nC; ++i ) { Ax_u[i] = ubA[i] - Ax[i]; Ax_l[i] = Ax[i] - lbA[i]; } } /* 2) Set new Hessian matrix, determine Hessian type and * regularise new Hessian matrix if necessary. */ /* a) Setup new Hessian matrix and determine its type. */ if ( H_new != 0 ) { setH( H_new ); hessianType = HST_UNKNOWN; if ( determineHessianType( ) != SUCCESSFUL_RETURN ) return THROWERROR( RET_SETUP_AUXILIARYQP_FAILED ); /* b) Regularise new Hessian if necessary. */ if ( ( hessianType == HST_ZERO ) || ( hessianType == HST_SEMIDEF ) || ( usingRegularisation( ) == BT_TRUE ) ) { regVal = 0.0; /* reset previous regularisation */ if ( regulariseHessian( ) != SUCCESSFUL_RETURN ) return THROWERROR( RET_SETUP_AUXILIARYQP_FAILED ); } } else { if ( H != 0 ) return THROWERROR( RET_NO_HESSIAN_SPECIFIED ); } /* 3) Setup QP gradient. */ if ( setupAuxiliaryQPgradient( ) != SUCCESSFUL_RETURN ) return THROWERROR( RET_SETUP_AUXILIARYQP_FAILED ); /* II) SETUP WORKING SETS AND MATRIX FACTORISATIONS: */ /* 1) Make a copy of current bounds/constraints ... */ Bounds oldBounds = bounds; Constraints oldConstraints = constraints; /* we're trying to find an active set with positive definite null * space Hessian twice: * - first for the current active set including all equalities * - second after moving all inactive variables to a bound * (depending on Options). This creates an empty null space and * is guaranteed to succeed. Thus this loop will exit after n_try=1. */ int n_try; for (n_try = 0; n_try < 2; ++n_try) { if (n_try > 0) { // the current active set leaves an indefinite null space Hessian // move all inactive variables to a bound, creating an empty null space for (int ii = 0; ii < nV; ++ii) if (oldBounds.getStatus (ii) == ST_INACTIVE) oldBounds.setStatus (ii, options.initialStatusBounds); } /* ... reset them ... */ bounds.init( nV ); constraints.init( nC ); /* ... and set them up afresh. */ if ( setupSubjectToType(lb_new,ub_new,lbA_new,ubA_new ) != SUCCESSFUL_RETURN ) return THROWERROR( RET_SETUP_AUXILIARYQP_FAILED ); if ( bounds.setupAllFree( ) != SUCCESSFUL_RETURN ) return THROWERROR( RET_SETUP_AUXILIARYQP_FAILED ); if ( constraints.setupAllInactive( ) != SUCCESSFUL_RETURN ) return THROWERROR( RET_SETUP_AUXILIARYQP_FAILED ); /* 2) Setup TQ factorisation. */ if ( setupTQfactorisation( ) != SUCCESSFUL_RETURN ) return THROWERROR( RET_SETUP_AUXILIARYQP_FAILED ); // check for equalities that have become bounds ... for (int ii = 0; ii < nC; ++ii) { if (oldConstraints.getType (ii) == ST_EQUALITY && constraints.getType (ii) == ST_BOUNDED) { if (oldConstraints.getStatus (ii) == ST_LOWER && y[nV+ii] < 0.0) oldConstraints.setStatus (ii, ST_UPPER); else if (oldConstraints.getStatus (ii) == ST_UPPER && y[nV+ii] > 0.0) oldConstraints.setStatus (ii, ST_LOWER); } } // ... and do the same also for the bounds! for (int ii = 0; ii < nV; ++ii) { if (oldBounds.getType(ii) == ST_EQUALITY && bounds.getType(ii) == ST_BOUNDED) { if (oldBounds.getStatus(ii) == ST_LOWER && y[ii] < 0.0) oldBounds.setStatus(ii, ST_UPPER); else if (oldBounds.getStatus(ii) == ST_UPPER && y[ii] > 0.0) oldBounds.setStatus(ii, ST_LOWER); } } /* 3) Setup old working sets afresh (updating TQ factorisation). */ if ( setupAuxiliaryWorkingSet( &oldBounds,&oldConstraints,BT_TRUE ) != SUCCESSFUL_RETURN ) return THROWERROR( RET_SETUP_AUXILIARYQP_FAILED ); /* Factorise projected Hessian * this now handles all special cases (no active bounds/constraints, no nullspace) */ returnvalue = computeProjectedCholesky( ); /* leave the loop if decomposition was successful, i.e. we have * found an active set with positive definite null space Hessian */ if ( returnvalue == SUCCESSFUL_RETURN ) break; } /* adjust lb/ub if we changed the old active set in the second try */ if (n_try > 0) { // as per setupAuxiliaryQPbounds assumptions ... oh the troubles for (int ii = 0; ii < nC; ++ii) Ax_l[ii] = Ax_u[ii] = Ax[ii]; setupAuxiliaryQPbounds (&bounds, &constraints, BT_FALSE); } status = QPS_AUXILIARYQPSOLVED; return SUCCESSFUL_RETURN; }
Complex::Complex(double a, double b) { setA(a); setB(b); }
complex_number::complex_number(double a, double b) { setA(a); setB(b); }
Complex::Complex(const Complex &other) { setA(other.a); setB(other.b); }
int main(void) { setA(); assert(b == 1); return 0; }