//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void FrameAnimationControl::slotTimerTriggered()
{
// Update current frame according to settings
if (m_forward)
{
if (m_currentFrame + 1 >= m_numFrames)
{
if (m_repeatFromStart)
{
m_currentFrame = 0;
}
else if (m_repeatFwdBwd)
{
setForward(false);
m_currentFrame--;
}
else
{
m_timer->stop();
m_currentFrame = m_numFrames - 1;
}
}
else
{
m_currentFrame++;
}
}
else
{
if (m_currentFrame - 1 < 0)
{
if (m_repeatFromStart)
{
m_currentFrame = m_numFrames - 1;
}
else if (m_repeatFwdBwd)
{
setForward(true);
m_currentFrame++; // Ends up as 1 (second frame) makes 2 1 0 1 2 and not 2 1 0 0 1 2
}
else
{
m_timer->stop();
m_currentFrame = 0;
}
}
else
{
m_currentFrame--;
}
}
// Emit signal with updated frame index
emit changeFrame(m_currentFrame);
}
double EuropeanOptionBlack76::getDeltaNumeric(double absoluteChangeInFormawrd)
{
double F = forward;
double dF = forward + absoluteChangeInFormawrd;
setForward(dF);
double price1 = getPremium();
setForward(F);
double price = getPremium();
return price1 - price;
}
double EuropeanOptionBlack76::getGammaNumeric(double absoluteChangeInFormawrd)
{
double F = forward;
double dF = forward + absoluteChangeInFormawrd;
double dF1 = forward - absoluteChangeInFormawrd;
setForward(dF);
double price1 = getPremium();
setForward(dF1);
double price2 = getPremium();
setForward(F);
double price = getPremium();
return (price1 - 2 * price + price2);
}
void Camera::turnLeft(double deltaAngle) {
deltaAngle = degreesToRadians(deltaAngle);
double ca = cos(deltaAngle);
double sa = sin(deltaAngle);
Vec3 right = forward->cross(*up);
setForward(*forward * ca - right * sa);
orthonormalize();
}
void Camera::turnDown(double deltaAngle) {
deltaAngle = degreesToRadians(deltaAngle);
double ca = cos(deltaAngle);
double sa = sin(deltaAngle);
setForward(*forward * ca - *up * sa);
setUp(*up * ca + *forward * sa);
orthonormalize();
}
void LaserBeam::init()
{
Gunshot::height=0.1f;
Gunshot::length=range;
Gunshot::width=0.1f;
setForward(0,0,1);
}
//set dc position - moves back or forward according to PID and current position,
//must be called on new input
void DcMotor::setPosition(int newPosition, bool verbose)
{
if (newPosition >= 0 && newPosition <= BUFFER)
newPosition = BUFFER;
if (newPosition >= ROD_LENGTH - BUFFER && newPosition <= ROD_LENGTH)
newPosition = ROD_LENGTH - BUFFER;
if (newPosition <= ROD_LENGTH - BUFFER && newPosition >= BUFFER)
{
if (verbose)
{
Serial.write((char)ArduinoCodes::DC_RECEIVED_OK);
}
if (digitalRead(END_BUTTON) == LOW) (*_curPosPtr) = ROD_LENGTH;
if (digitalRead(START_BUTTON) == LOW) (*_curPosPtr) = 0;
_lastReceivedPosition = newPosition;
_setpoint = newPosition;
_input = *_curPosPtr;
_pid->Compute();
if (_setpoint > (*_curPosPtr) + PID_ERROR)
{
if (digitalRead(END_BUTTON) != LOW)
{
setForward();
setSpeed(_output);
}
else
{
setSpeed(0);
}
}
else if (_setpoint < (*_curPosPtr) - PID_ERROR)
{
if (digitalRead(START_BUTTON) != LOW)
{
setBackward();
setSpeed(_output*(-1));
}
else
{
setSpeed(0);
}
}
//Position reached
else
{
setSpeed(0);
}
}
else
{
if (verbose) Serial.write((char)ArduinoCodes::DC_RANGE_INVALID);
}
}
//set dc position - moves back or forward according to PID and current position,
//must be called on new input
TxCode DcMotor::setPosition(int newPosition)
{
TxCode result = TxCode::TX_NA;
if (newPosition >= 0 && newPosition <= BUFFER)
newPosition = BUFFER;
if (newPosition >= ROD_LENGTH - BUFFER && newPosition <= ROD_LENGTH)
newPosition = ROD_LENGTH - BUFFER;
if (newPosition <= ROD_LENGTH - BUFFER && newPosition >= BUFFER)
{
if (digitalRead(END_BUTTON) == LOW) (*_curPosPtr) = ROD_LENGTH;
if (digitalRead(START_BUTTON) == LOW) (*_curPosPtr) = 0;
result = TxCode::TX_DC_RECEIVED_OK;
_lastReceivedPosition = newPosition;
_setpoint = newPosition;
_input = *_curPosPtr;
_pid->Compute();
if (_setpoint > (*_curPosPtr) + PID_ERROR)
{
if (digitalRead(END_BUTTON) != LOW)
{
setForward();
setSpeed(_output);
}
else
{
setSpeed(0);
}
}
else if (_setpoint < (*_curPosPtr) - PID_ERROR)
{
if (digitalRead(START_BUTTON) != LOW)
{
setBackward();
setSpeed(_output*(-1));
}
else
{
setSpeed(0);
}
}
//Position reached
else
{
setSpeed(0);
}
}
else
{
result = TxCode::TX_DC_RANGE_INVALID;
}
return result;
}
void Balaenidae::init()
{
//Load the model
_model = (Model*)T3DSModel::loadModel("units/carrier.3ds",-1.4f,0.0f,0.0f,1,_textureMetal);
if (_model != NULL)
_model->setAnimation("run");
setForward(0,0,1);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void FrameAnimationControl::setDefault()
{
setCurrentFrame(0);
setNumFrames(0);
setTimeout(TIMEOUT_DEFAULT);
setForward(true);
setRepeatFromStart(false);
setRepeatFwdBwd(false);
// m_lastTimeStamp = 0;
}
BlackScholesGreeks EuropeanOptionBlack76::getOptionPriceAndGreeksNumeric(double dF, double dV, double dY, double dR)
{
double F = forward;
double sd = standardDeviation;
double df = discountFactor;
double yte = yearsToExpiry;
double yts = yearsToSettlement;
double X = strike;
double sqrtdt = sqrt(yte);
double price = getPremium();
// Delta
setForward(F + dF);
double deltaPremium = getPremium();
double delta = deltaPremium - price;
// Gamma
setForward(F - dF);
double gammaPremium = getPremium();
double gamma = (deltaPremium - 2 * price + gammaPremium);
setForward(F);
// Vega
double originalVol = sd / sqrtdt;
double sd1 = (originalVol + dV) * sqrtdt;
setStandardDeviation(sd1);
double priceVega = getPremium();
double vega = priceVega - price;
// setStandardDeviation(sd1); will do a setParamters in Theta
// Theta
sd1 = (sd / sqrt(yte)) * sqrt(yte - dY);
double df1 = exp(log(df) / yts * (yts - dY));
setParameters(F, X, yte - dY, yts - dY, sd1, df1);
double priceTheta = getPremium();
double theta = priceTheta - price;
setParameters(F, X, yte, yts, sd, df);
// Rho
df1 = exp((log(df) / yts - dR) * yts);
setDiscountFactor(df1);
double priceRho = getPremium();
double rho = priceRho - price;
setParameters(F, X, yte, yts, sd, df);
return BlackScholesGreeks(price, delta, gamma, theta, vega, rho);
}
void Buggy::init()
{
_model = MD2Model::loadModel("walrus.md2");
if (_model != NULL)
_model->setAnimation("run");
else
printf ("Model has been initialized");
setForward(0,0,1);
}
void SteeringVehicle::resetLocalSpace()
{
setForward(mForwardVector);
setSide(localRotateForwardToSide(getForward()));
setUp(Vector3::UNIT_Y);
Vector3 pos = mCreature->getPosition();
setPosition(pos);
Vector3 src = mCreature->getOrientation()*Vector3::NEGATIVE_UNIT_Z;
// regenerate local space(by default: align vehicle's forward axis with
// new velocity, but this behavior may be overridden by derived classes.)
regenerateOrthonormalBasisUF(src);
}
void Runway::init()
{
//Load the model
_model = (Model*)T3DSModel::loadModel("structures/runway.3ds",-466.06f,0.0f,0.0f,20,1,10,Structure::texture);
if (_model != NULL)
_model->setAnimation("run");
Structure::height=2;
Structure::length=1000;
Structure::width=20;
setForward(0,0,1);
}
void VK::sendMessage(int guid, int userId, bool isChat, QString text, QString forward, QString attachments) {
auto handler = new VKHandlerSendMessage(&storage(), this);
handler->setGuid(guid);
handler->setAttachments(attachments);
handler->setForward(forward);
handler->setIsChat(isChat);
handler->setText(text);
handler->setUserId(userId);
//QObject::connect(handler, &VKAbstractHandler::ready, this, &VK::sendHandlertoScript);
QObject::connect(handler, &VKAbstractHandler::sendRequest, this, &VK::processHandler);
sendNetworkRequest(handler);
}
PIC_INLINE FilterDCT1D::FilterDCT1D(int nCoeff, bool bForward)
{
this->coeff = NULL;
this->nCoeff = nCoeff;
if(bForward) {
setForward();
} else {
setInverse();
}
sqr[0] = sqrtf(1.0f / float(nCoeff));
sqr[1] = sqrtf(2.0f / float(nCoeff));
dirs[0] = 1;
dirs[1] = 0;
dirs[2] = 0;
}
void Buggy::doDynamics(dBodyID body)
{
//dReal *v = (dReal *)dBodyGetLinearVel(body);
//dJointSetHinge2Param (carjoint[0],dParamVel,getThrottle());
//dJointSetHinge2Param (carjoint[0],dParamFMax,1000);
dJointSetHinge2Param (carjoint[0],dParamVel2,yRotAngle);
dJointSetHinge2Param (carjoint[0],dParamFMax2,1000);
dJointSetHinge2Param (carjoint[1],dParamVel2,yRotAngle);
dJointSetHinge2Param (carjoint[1],dParamFMax2,1000);
// steering
dReal v = dJointGetHinge2Angle1 (carjoint[0]);
if (v > 0.1) v = 0.1;
if (v < -0.1) v = -0.1;
v *= 10.0;
//dJointSetHinge2Param (carjoint[0],dParamVel,0);
//dJointSetHinge2Param (carjoint[0],dParamFMax,1000);
//dJointSetHinge2Param (carjoint[0],dParamLoStop,-0.75);
//dJointSetHinge2Param (carjoint[0],dParamHiStop,0.75);
//dJointSetHinge2Param (carjoint[0],dParamFudgeFactor,0.1);
//dBodyAddRelForce (body,0, 0,getThrottle());
// This should be after the world step
/// stuff
dVector3 result;
dBodyVectorToWorld(body, 0,0,1,result);
setForward(result[0],result[1],result[2]);
const dReal *dBodyPosition = dBodyGetPosition(body);
const dReal *dBodyRotation = dBodyGetRotation(body);
setPos(dBodyPosition[0],dBodyPosition[1],dBodyPosition[2]);
setLocation((float *)dBodyPosition, (float *)dBodyRotation);
}
//!Perform calculations from initial state for viterbi and forward
void basicTrellis::initForwardViterbi(){
sequencePosition=0;
previousStatePtr=NULL;
std::vector<state*>* init = hmm->getInitialTo();
state* initial=hmm->getInitial();
for (unsigned int x=0; x<init->size();x++){
currentStatePtr=(*init)[x];
currentState = currentStatePtr->getIterator();
double viterbiValue = ((*initial).getTrans(currentState))->getTransition(0,NULL) + currentStatePtr->get_emission(*seq,sequencePosition);
if (viterbiValue>-INFINITY){
DefinedStates->insert(currentStatePtr);
_nextStates->insert(currentStatePtr->getToBegin(),currentStatePtr->getToEnd());
setViterbi(viterbiValue);
setForward(viterbiValue);
}
}
return;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void FrameAnimationControl::slotPlayBwd()
{
setForward(false);
start();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void FrameAnimationControl::slotPlayFwd()
{
setForward(true);
start();
}
//!Calculate the forward score for a given cell
void simpleTrellis::calcForward() {
for(currentStatesIterator = currentStates->begin(); currentStatesIterator!=currentStates->end(); currentStatesIterator++) {
currentStatePtr = (*currentStatesIterator);
currentState = currentStatePtr->getIterator();
double emm;
//If emission is not yet calculated for the cell
if (!trell[sequencePosition][currentState].emmCalculated) {
//Calculate emission
emm=currentStatePtr->get_emission(*seq, sequencePosition);
//Check for external definition
if (externalDefinitionSet) {
emm+=seq->getWeight(sequencePosition, currentState);
}
//Store emission value in cell
trell[sequencePosition][currentState].emmCalculated=true;
trell[sequencePosition][currentState].emm=emm;
}
else { //emm previously calculated
//Get previously calculated emm value;
emm = trell[sequencePosition][currentState].emm;
}
std::vector<state*>::iterator it;
for(it=currentStatePtr->getFromBegin(); it!=currentStatePtr->getFromEnd(); it++) {
previousStatePtr=(*it);
if (previousStates->count(previousStatePtr)) {
previousState = previousStatePtr->getIterator();
double trans;
if (trell[sequencePosition][currentState].trans.count(previousStatePtr)) {
trans = trell[sequencePosition][currentState].trans[previousStatePtr];
}
else {
trans = getTransition();
trell[sequencePosition][currentState].trans[previousStatePtr]=trans;
}
#ifdef VERBOSE
std::cout << "Position:\t" << sequencePosition <<std::endl;
std::cout << "State:\t" << currentState <<std::endl;
std::cout << "Previous State:\t"<<previousState << std::endl;
std::cout << "Transition:\t" << trans <<std::endl;
std::cout << "Emission:\t" << emm << std::endl;
#endif
double prelimValue = emm + trans + trell[sequencePosition-1][previousState].forw;
if(prelimValue>-INFINITY) {
DefinedStates->insert(currentStatePtr);
_nextStates->insert(currentStatePtr->getToBegin(),currentStatePtr->getToEnd());
setForward(prelimValue);
}
}
}
}
#ifdef VERBOSE
std::cout <<std::endl;
#endif
return;
}
void Camera::orthonormalize() {
Vec3 right = forward->cross(*up);
setForward(up->cross(right));
setUp(up->normalize());
setForward(forward->normalize());
}
