std::string SignFactory::getLaterByIndex(int inx) { SignMap::iterator iter = m_SignMap.find(inx); Sign* pSign = iter->second; std::string latter = pSign->getLatter(); return latter; }
void RandomScroll::run(Sign &sign, uint8_t layer){ sign.textChanged = true; char random_char = char(' ' + random8(95) ); sign.pushChar(random_char); sign.setCharacters(); }
/** * Place a sign at the given coordinates. Ownership of sign has * no effect whatsoever except for the colour the sign gets for easy recognition, * but everybody is able to rename/remove it. * @param tile tile to place sign at * @param flags type of operation * @param p1 unused * @param p2 unused * @param text unused * @return the cost of this operation or an error */ CommandCost CmdPlaceSign(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text) { /* Try to locate a new sign */ if (!Sign::CanAllocateItem()) return_cmd_error(STR_ERROR_TOO_MANY_SIGNS); /* Check sign text length if any */ if (!StrEmpty(text) && Utf8StringLength(text) >= MAX_LENGTH_SIGN_NAME_CHARS) return CMD_ERROR; /* When we execute, really make the sign */ if (flags & DC_EXEC) { Sign *si = new Sign(_current_company); int x = TileX(tile) * TILE_SIZE; int y = TileY(tile) * TILE_SIZE; si->x = x; si->y = y; si->z = GetSlopeZ(x, y); if (!StrEmpty(text)) { si->name = strdup(text); } si->UpdateVirtCoord(); InvalidateWindowData(WC_SIGN_LIST, 0, 0); _new_sign_id = si->index; } return CommandCost(); }
/** * Rename a sign. If the new name of the sign is empty, we assume * the user wanted to delete it. So delete it. Ownership of signs * has no meaning/effect whatsoever except for eyecandy * @param tile unused * @param flags type of operation * @param p1 index of the sign to be renamed/removed * @param p2 unused * @param text the new name or an empty string when resetting to the default * @return the cost of this operation or an error */ CommandCost CmdRenameSign(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text) { Sign *si = Sign::GetIfValid(p1); if (si == NULL) return CMD_ERROR; /* Rename the signs when empty, otherwise remove it */ if (!StrEmpty(text)) { if (Utf8StringLength(text) >= MAX_LENGTH_SIGN_NAME_CHARS) return CMD_ERROR; if (flags & DC_EXEC) { /* Delete the old name */ free(si->name); /* Assign the new one */ si->name = strdup(text); si->owner = _current_company; si->UpdateVirtCoord(); InvalidateWindowData(WC_SIGN_LIST, 0, 1); } } else { // Delete sign if (flags & DC_EXEC) { si->sign.MarkDirty(); delete si; InvalidateWindowData(WC_SIGN_LIST, 0, 0); } } return CommandCost(); }
/** Update the coordinates of all signs */ void UpdateAllSignVirtCoords() { Sign *si; FOR_ALL_SIGNS(si) { si->UpdateVirtCoord(); } }
Sign* Sign::create(cocos2d::Vec2* points, int nbrPoints, std::string spriteFile) { Sign * node = new Sign(); if (node) { node->init(points, nbrPoints, spriteFile); node->autorelease(); return node; } CC_SAFE_DELETE(node); return NULL; }
void RandomLetters::run(Sign &sign, EffectData &data, uint8_t layer){ sign.textChanged = true; uint8_t letters_count = sign.letterCount(); char random_char; for(uint8_t i=0; i < letters_count; i++){ random_char = ' ' + random(95); sign.letter(i) -> setChar(random_char); } }
RETCODE World::EntityLoad_Sign(hQBSP qbsp, const EntityParse & entityDat) { hTXT txt; int r,g,b,a; //create new sign Sign *newObj = new Sign; assert(newObj); /////////////////////////////////////////////////////// //load up the common stuff EntityLoad_CommonObject(qbsp, entityDat, dynamic_cast<Object *>(newObj)); const char *pStr; /////////////////////////////////////////////////////// //load image pStr = entityDat.GetVal("image"); if(pStr) { string imgPath = GAMEFOLDER; imgPath += "\\"; imgPath += pStr; txt = TextureCreate(0, imgPath.c_str(), false, 0); } /////////////////////////////////////////////////////// //get color pStr = entityDat.GetVal("color"); if(pStr) { sscanf(pStr, "%d %d %d %d", &r,&g,&b,&a); } if(txt) { float sX = (SCRN_W/2) - (TextureGetWidth(txt)/2); float sY = (SCRN_H/2) - (TextureGetHeight(txt)/2); float eX = sX + TextureGetWidth(txt); float eY = sY + TextureGetHeight(txt); sX /= SCRN_W; sY /= SCRN_H; eX /= SCRN_W; eY /= SCRN_H; newObj->SetImageDisplay(ImageDisplayAdd(txt, sX,sY,eX,eY, r,g,b,a)); TextureDestroy(&txt); } return RETCODE_SUCCESS; }
void WavePixels::run(Sign &sign, EffectData &data, uint8_t ci){ uint16_t angle = (millis() % cycleTime[ci])*UINT16_MAX/cycleTime[ci]; int16_t delta_hue = hueA[ci] * sin16(angle)/UINT16_MAX; uint16_t seg_count = sign.segmentCount(); bool on = (ci == 0); for(uint8_t i=0; i < seg_count; i++){ Segment *curr_seg = sign.segments[i]; if(curr_seg -> isOn == on){ curr_seg -> setColor(color[ci]); delta_hue = -delta_hue; int16_t hue_add = delta_hue; uint8_t pixel_count = curr_seg -> pixelCount(); for(uint8_t j = 0; j < pixel_count; j++ ){ Pixel *currPixel = curr_seg -> pixels[j]; currPixel -> addHue16(hue_add); hue_add += delta_hue; } } } }
int main (int argc, char * argv[]) { QApplication app(argc,argv); Signfactory sf; Sign *s = sf.createSign("/"); s->setA(1);s->setB(0); try{ qDebug()<<s->getResult(); } catch(...) {} delete s; #ifdef use_origin std::shared_ptr<caculate> c(new caculate); #else QSharedPointer<caculate> c(new caculate); #endif c->show(); return app.exec(); }
void RainbowSegment::run(Sign &sign, uint8_t layer){ if( sign.textChanged ){ this -> signWasUpdated(sign);} uint8_t segment_count = sign.segmentCount(); CHSV curr_color = color[layer]; if(changeOnBeat && sign.onBeat){ color[layer].hue += beatStep[layer]; } for(uint8_t i=0; i<segment_count; i++){ Segment* curr_segment = sign.segments[i]; curr_segment -> setColor(layer, curr_color); curr_color.hue += hueStep[layer]; } }
void Scrolling::run(Sign &sign, EffectData &data, uint8_t layer){ if(beatIdx++ % numBeats > 0){ return;} sign.textChanged = true; char word[4]; if(randomLetterIdx >= 0){ this->setRandomLetter(word); }else{ for(uint8_t i=0; i< LETTERS_COUNT; i++){ uint8_t idx = (beatIdx+i) % charCount; word[i] = buffer[idx]; } } sign.setWord( String( word ) ); }
inline UnitVector3d operator*(Sign sign, const UnitVector3d& unitVector) { return UnitVector3d(sign.value() * unitVector.components()); }
//invoke only once void SignFactory::fillSignMap() { int soundType = SIGN_SOUND_DEFAULT; //latters for(int i=0;i<LETTERS_LENGTH;i++) { char stringSignName[20] = { 0 }; sprintf(stringSignName,"%s%d.png",LatterfileNameByRez.c_str(), i); Sign* pSign = Sign::create(stringSignName); pSign->setAnchorPoint(Vec2(0.0,0.0)); //char ch = m_LatersStr[i-1]; std::string latter = pUT->int_to_string(i); pSign->setLatterInx((i)); pSign->setLatter(latter); pSign->setTag(sign_tags::LETTER_SIGH); if(soundType == IS_FALSE) { char stringSignSoundName[50] = { 0 }; sprintf(stringSignSoundName,"%s/%s%d.mp3",lang_sound.c_str(), sLetterfileSounds_fnt_to_slc.c_str(), i); //std::string stringSignSoundName ="x"; std::string stdstringSignSoundName(stringSignSoundName); pSign->setFontToSolutionSound(stdstringSignSoundName); pSign->setSolutionToFontSound(core::Settings::getInstance()->getSoundManager() .soundEffectClick_FromSolutionToFont); //delete stringSignSoundName; } else { pSign->setSolutionToFontSound(core::Settings::getInstance()->getSoundManager() .soundEffectClick_FromSolutionToFont); pSign->setFontToSolutionSound(core::Settings::getInstance()->getSoundManager() .soundEffectClick_FromSolutionToFont); } pSign->retain(); m_SignMap.insert(std::pair<int, Sign*>((i),pSign)); //m_SignToNumMap.insert(std::pair<std::string,int>(latter,(i-1))); } //image container Sign* pSignContainer = Sign::create(LatterContainerfileNameByRez); pSignContainer->setAnchorPoint(Vec2(0.0,0.0)); pSignContainer->setLatterInx(sign_tags::CONTAINER_SIGH); pSignContainer->retain(); m_SignMap.insert(std::pair<int, Sign*>(sign_tags::CONTAINER_SIGH,pSignContainer)); //line break Sign* pSignLineBreak = Sign::create(LatterContainerfileNameByRez); pSignLineBreak->setAnchorPoint(Vec2(0.0,0.0)); pSignLineBreak->setLatterInx(sign_tags::SEPERATOR_SIGH); pSignLineBreak->retain(); m_SignMap.insert(std::pair<int, Sign*>(sign_tags::SEPERATOR_SIGH,pSignLineBreak)); //scalefactor Sign* SignTest = getSign(1); Size LatterOrigSize = SignTest->getBoundingBox().size; // must be set first TODO fix this... float winWidth = m_Parent->pFontSelectionContainer->visibleSize.width; float locallatterScaleFactor = pUT->getScaleFactorBasedOnWinWidth(winWidth,LatterOrigSize); setLatterScaleFactor(locallatterScaleFactor); //SignTest->setScale(getLatterScaleFactor()); pUT->setSignScalefactor(SignTest); setLatterScalledSize(SignTest->getBoundingBox().size); }
void SymplecticRungeKuttaNyströmIntegrator<Position, order, time_reversible, evaluations, composition>::Solve( IntegrationProblem<ODE> const& problem, Time const& step) const { using Displacement = typename ODE::Displacement; using Velocity = typename ODE::Velocity; using Acceleration = typename ODE::Acceleration; // Argument checks. CHECK_NOTNULL(problem.initial_state); int const dimension = problem.initial_state->positions.size(); CHECK_EQ(dimension, problem.initial_state->velocities.size()); CHECK_NE(Time(), step); Sign const integration_direction = Sign(step); if (integration_direction.Positive()) { // Integrating forward. CHECK_LT(problem.initial_state->time.value, problem.t_final); } else { // Integrating backward. CHECK_GT(problem.initial_state->time.value, problem.t_final); } typename ODE::SystemState current_state = *problem.initial_state; // Time step. Time const& h = step; Time const abs_h = integration_direction * h; // Current time. This is a non-const reference whose purpose is to make the // equations more readable. DoublePrecision<Instant>& t = current_state.time; // Position increment. std::vector<Displacement> Δq(dimension); // Velocity increment. std::vector<Velocity> Δv(dimension); // Current position. This is a non-const reference whose purpose is to make // the equations more readable. std::vector<DoublePrecision<Position>>& q = current_state.positions; // Current velocity. This is a non-const reference whose purpose is to make // the equations more readable. std::vector<DoublePrecision<Velocity>>& v = current_state.velocities; // Current Runge-Kutta-Nyström stage. std::vector<Position> q_stage(dimension); // Accelerations at the current stage. std::vector<Acceleration> g(dimension); // The first full stage of the step, i.e. the first stage where // exp(bᵢ h B) exp(aᵢ h A) must be entirely computed. // Always 0 in the non-FSAL kBA case, always 1 in the kABA case since b₀ = 0, // means the first stage is only exp(a₀ h A), and 1 after the first step // in the kBAB case, since the last right-hand-side evaluation can be used for // exp(bᵢ h B). int first_stage = composition == kABA ? 1 : 0; while (abs_h <= Abs((problem.t_final - t.value) - t.error)) { std::fill(Δq.begin(), Δq.end(), Displacement{}); std::fill(Δv.begin(), Δv.end(), Velocity{}); if (first_stage == 1) { for (int k = 0; k < dimension; ++k) { if (composition == kBAB) { // exp(b₀ h B) Δv[k] += h * b_[0] * g[k]; } // exp(a₀ h A) Δq[k] += h * a_[0] * (v[k].value + Δv[k]); } } for (int i = first_stage; i < stages_; ++i) { for (int k = 0; k < dimension; ++k) { q_stage[k] = q[k].value + Δq[k]; } problem.equation.compute_acceleration(t.value + c_[i] * h, q_stage, &g); for (int k = 0; k < dimension; ++k) { // exp(bᵢ h B) Δv[k] += h * b_[i] * g[k]; // exp(aᵢ h A) Δq[k] += h * a_[i] * (v[k].value + Δv[k]); } } if (composition == kBAB) { first_stage = 1; } // Increment the solution. t.Increment(h); for (int k = 0; k < dimension; ++k) { q[k].Increment(Δq[k]); v[k].Increment(Δv[k]); } problem.append_state(current_state); } }
Status EmbeddedExplicitRungeKuttaNyströmIntegrator<Position, higher_order, lower_order, stages, first_same_as_last>:: Instance::Solve(Instant const& t_final) { using Displacement = typename ODE::Displacement; using Velocity = typename ODE::Velocity; using Acceleration = typename ODE::Acceleration; auto const& a = integrator_.a_; auto const& b_hat = integrator_.b_hat_; auto const& b_prime_hat = integrator_.b_prime_hat_; auto const& b = integrator_.b_; auto const& b_prime = integrator_.b_prime_; auto const& c = integrator_.c_; auto& current_state = this->current_state_; auto& append_state = this->append_state_; auto& adaptive_step_size = this->adaptive_step_size_; auto const& equation = this->equation_; // |current_state| gets updated as the integration progresses to allow // restartability. // State before the last, truncated step. std::experimental::optional<typename ODE::SystemState> final_state; // Argument checks. int const dimension = current_state.positions.size(); Sign const integration_direction = Sign(adaptive_step_size.first_time_step); if (integration_direction.Positive()) { // Integrating forward. CHECK_LT(current_state.time.value, t_final); } else { // Integrating backward. CHECK_GT(current_state.time.value, t_final); } // Time step. Time h = adaptive_step_size.first_time_step; // Current time. This is a non-const reference whose purpose is to make the // equations more readable. DoublePrecision<Instant>& t = current_state.time; // Position increment (high-order). std::vector<Displacement> Δq_hat(dimension); // Velocity increment (high-order). std::vector<Velocity> Δv_hat(dimension); // Current position. This is a non-const reference whose purpose is to make // the equations more readable. std::vector<DoublePrecision<Position>>& q_hat = current_state.positions; // Current velocity. This is a non-const reference whose purpose is to make // the equations more readable. std::vector<DoublePrecision<Velocity>>& v_hat = current_state.velocities; // Difference between the low- and high-order approximations. typename ODE::SystemStateError error_estimate; error_estimate.position_error.resize(dimension); error_estimate.velocity_error.resize(dimension); // Current Runge-Kutta-Nyström stage. std::vector<Position> q_stage(dimension); // Accelerations at each stage. // TODO(egg): this is a rectangular container, use something more appropriate. std::vector<std::vector<Acceleration>> g(stages); for (auto& g_stage : g) { g_stage.resize(dimension); } bool at_end = false; double tolerance_to_error_ratio; // The first stage of the Runge-Kutta-Nyström iteration. In the FSAL case, // |first_stage == 1| after the first step, since the first RHS evaluation has // already occured in the previous step. In the non-FSAL case and in the // first step of the FSAL case, |first_stage == 0|. int first_stage = 0; // The number of steps already performed. std::int64_t step_count = 0; // No step size control on the first step. goto runge_kutta_nyström_step; while (!at_end) { // Compute the next step with decreasing step sizes until the error is // tolerable. do { // Adapt step size. // TODO(egg): find out whether there's a smarter way to compute that root, // especially since we make the order compile-time. h *= adaptive_step_size.safety_factor * std::pow(tolerance_to_error_ratio, 1.0 / (lower_order + 1)); // TODO(egg): should we check whether it vanishes in double precision // instead? if (t.value + (t.error + h) == t.value) { return Status(termination_condition::VanishingStepSize, "At time " + DebugString(t.value) + ", step size is effectively zero. Singularity or " "stiff system suspected."); } runge_kutta_nyström_step: // Termination condition. Time const time_to_end = (t_final - t.value) - t.error; at_end = integration_direction * h >= integration_direction * time_to_end; if (at_end) { // The chosen step size will overshoot. Clip it to just reach the end, // and terminate if the step is accepted. h = time_to_end; final_state = current_state; } // Runge-Kutta-Nyström iteration; fills |g|. for (int i = first_stage; i < stages; ++i) { Instant const t_stage = t.value + c[i] * h; for (int k = 0; k < dimension; ++k) { Acceleration Σj_a_ij_g_jk{}; for (int j = 0; j < i; ++j) { Σj_a_ij_g_jk += a[i][j] * g[j][k]; } q_stage[k] = q_hat[k].value + h * (c[i] * v_hat[k].value + h * Σj_a_ij_g_jk); } equation.compute_acceleration(t_stage, q_stage, g[i]); } // Increment computation and step size control. for (int k = 0; k < dimension; ++k) { Acceleration Σi_b_hat_i_g_ik{}; Acceleration Σi_b_i_g_ik{}; Acceleration Σi_b_prime_hat_i_g_ik{}; Acceleration Σi_b_prime_i_g_ik{}; // Please keep the eight assigments below aligned, they become illegible // otherwise. for (int i = 0; i < stages; ++i) { Σi_b_hat_i_g_ik += b_hat[i] * g[i][k]; Σi_b_i_g_ik += b[i] * g[i][k]; Σi_b_prime_hat_i_g_ik += b_prime_hat[i] * g[i][k]; Σi_b_prime_i_g_ik += b_prime[i] * g[i][k]; } // The hat-less Δq and Δv are the low-order increments. Δq_hat[k] = h * (h * (Σi_b_hat_i_g_ik) + v_hat[k].value); Displacement const Δq_k = h * (h * (Σi_b_i_g_ik) + v_hat[k].value); Δv_hat[k] = h * Σi_b_prime_hat_i_g_ik; Velocity const Δv_k = h * Σi_b_prime_i_g_ik; error_estimate.position_error[k] = Δq_k - Δq_hat[k]; error_estimate.velocity_error[k] = Δv_k - Δv_hat[k]; } tolerance_to_error_ratio = adaptive_step_size.tolerance_to_error_ratio(h, error_estimate); } while (tolerance_to_error_ratio < 1.0); if (first_same_as_last) { using std::swap; swap(g.front(), g.back()); first_stage = 1; } // Increment the solution with the high-order approximation. t.Increment(h); for (int k = 0; k < dimension; ++k) { q_hat[k].Increment(Δq_hat[k]); v_hat[k].Increment(Δv_hat[k]); } append_state(current_state); ++step_count; if (step_count == adaptive_step_size.max_steps && !at_end) { return Status(termination_condition::ReachedMaximalStepCount, "Reached maximum step count " + std::to_string(adaptive_step_size.max_steps) + " at time " + DebugString(t.value) + "; requested t_final is " + DebugString(t_final) + "."); } } // The resolution is restartable from the last non-truncated state. CHECK(final_state); current_state = *final_state; return Status(termination_condition::Done, ""); }
/** testing. */ int mainCryptopp(const char* encryptPath, const char* decryptPath) { printf("/***************************************************************************\n"); printf("C++ crypto, wrap cryptopp interface, reference to www.cryptopp.com\n"); printf("[email protected] 2006-5-25\n"); printf("***************************************************************************/\n"); // base64 testing. { printf("\n=======================base64=====================\n"); // input data. const char * indata = "bsmith is a good guy."; int inlen = (int)strlen(indata); printf("inlen=%d\n", inlen); printf("indata(hex)="); dump(indata, inlen); // encoding ... int maxoutlen = Base64::getCipherLen(inlen); printf("maxoutlen=%d\n", maxoutlen); char * outdata = new char[maxoutlen]; int outlen = Base64::encode(indata, inlen, outdata); printf("outlen=%d\n", outlen); printf("outdata(hex)="); dump(outdata, outlen); // encoded base64 string. char * outstr = new char[outlen+1]; memcpy(outstr, outdata, outlen); outstr[outlen] = 0x00; printf("outstr=%s\n", outstr); // decoding ... int maxinlen = Base64::getPlainLen(outlen); printf("maxinlen=%d\n", maxinlen); char * orgdata = new char[maxinlen]; int orglen = Base64::decode(outdata, outlen, orgdata); printf("orglen=%d\n", orglen); printf("orgdata(hex)="); dump(orgdata, orglen); delete[] outdata; delete[] outstr; delete[] orgdata; } // base16 testing. { printf("\n=======================base16=====================\n"); // input data. const char * indata = "bsmith is a good guy."; int inlen = (int)strlen(indata); printf("inlen=%d\n", inlen); printf("indata(hex)="); dump(indata, inlen); // encoding ... int maxoutlen = Base16::getCipherLen(inlen); printf("maxoutlen=%d\n", maxoutlen); char * outdata = new char[maxoutlen]; int outlen = Base16::encode(indata, inlen, outdata); printf("outlen=%d\n", outlen); printf("outdata(hex)="); dump(outdata, outlen); // encoded base16 string. char * outstr = new char[outlen+1]; memcpy(outstr, outdata, outlen); outstr[outlen] = 0x00; printf("outstr=%s\n", outstr); // decoding ... int maxinlen = Base16::getPlainLen(outlen); printf("maxinlen=%d\n", maxinlen); char * orgdata = new char[maxinlen]; int orglen = Base16::decode(outdata, outlen, orgdata); printf("orglen=%d\n", orglen); printf("orgdata(hex)="); dump(orgdata, orglen); delete[] outdata; delete[] outstr; delete[] orgdata; } // RSA testing. { printf("\n=======================RSA PKCS #1=====================\n"); // key // N factor in RSA, aslo called modulus. const char * N = "90755611487566208138950675092879865387596685014726501531250157258482495478524769456222913843665634824684037468817980814231054856125127115894189385717148934026931120932481402379431731629550862846041784305274651476086892165805223719552575599962253392248079811268061946102234935422772131475340988882825043233323"; // e factor in RSA, aslo called public exponent. const char * e = "65537"; // d factor in RSA, aslo called private exponent const char * d = "17790520481266507102264359414044396762660094486842415203197747383916331528947124726552875080482359744765793816651732601742929364124685415229452844016482477236658413327331659722342187036963943428678684677279032263501011143882814728160215380051287503219732737197808611144507720521201393129692996926599975297921"; // input data. const char * indata = "bsmith is a good guy."; int inlen = (int)strlen(indata); printf("inlen=%d\n", inlen); printf("indata(hex)="); dump(indata, inlen); // init RSA public key encryptor. RSA enc; enc.initPublicKey(N, e); // encrypt. int maxoutlen = enc.getCipherLen(inlen); printf("maxoutlen=%d\n", maxoutlen); char * outdata = new char[maxoutlen]; int outlen = enc.encrypt(indata, inlen, outdata); printf("outlen=%d\n", outlen); printf("outdata(hex)="); dump(outdata, outlen); // init private for RSA decryptor. RSA dec; dec.initPrivateKey(N, e, d); // decrypt. int maxinlen = dec.getPlainLen(outlen); printf("maxinlen=%d\n", maxinlen); char * orgdata = new char[maxinlen]; int orglen = dec.decrypt(outdata, outlen, orgdata); printf("orglen=%d\n", orglen); printf("orgdata(hex)="); dump(orgdata, orglen); delete[] outdata; delete[] orgdata; } // AES/CBC/PKCS5Padding testing. { printf("\n=======================AES/CBC/PKCS5Padding=====================\n"); // key const char * key = "0123456789abcdef"; // iv const char * iv = "fedcba9876543210"; // init AES. AES aes; aes.init(key, 16, iv); // input data. // const char * indata = "bsmith is a good guy."; // const char * indata = "bsmith."; const char * indata = "I am a good guy."; int inlen = (int)strlen(indata); printf("inlen=%d\n", inlen); printf("indata(hex)="); dump(indata, inlen); // encrypt. int maxoutlen = aes.getCipherLen(inlen); printf("maxoutlen=%d\n", maxoutlen); char * outdata = new char[maxoutlen]; int outlen = 0; { outlen = aes.encrypt(indata, inlen, outdata); printf("outlen=%d\n", outlen); printf("outdata(hex)="); dump(outdata, outlen); } { outlen = aes.encrypt(indata, inlen, outdata); printf("outlen=%d\n", outlen); printf("outdata(hex)="); dump(outdata, outlen); } // decrypt. int maxinlen = aes.getPlainLen(outlen); printf("maxinlen=%d\n", maxinlen); char * orgdata = new char[maxinlen]; { int orglen = aes.decrypt(outdata, outlen, orgdata); printf("orglen=%d\n", orglen); printf("orgdata(hex)="); dump(orgdata, orglen); } { int orglen = aes.decrypt(outdata, outlen, orgdata); printf("orglen=%d\n", orglen); printf("orgdata(hex)="); dump(orgdata, orglen); } delete[] outdata; delete[] orgdata; } // SHA1 testing. { printf("\n=======================SHA1=====================\n"); SHA1 sha1; // input data. const char * indata = "bsmith is a good guy."; int inlen = (int)strlen(indata); printf("inlen=%d\n", inlen); printf("indata(hex)="); dump(indata, inlen); // one time digest. { char * outdata = new char[sha1.getCipherLen(inlen)]; int outlen = sha1.digest(indata, inlen, outdata); printf("outlen=%d\n", outlen); printf("outdata(hex)="); dump(outdata, outlen); delete[] outdata; } // serval times { char * outdata = new char[sha1.getCipherLen(inlen)]; sha1.update(indata, 5); sha1.update(indata+5, inlen-5); int outlen = sha1.final(outdata); printf("outlen=%d\n", outlen); printf("outdata(hex)="); dump(outdata, outlen); delete[] outdata; } // one time digest. { char * outdata = new char[sha1.getCipherLen(inlen)]; int outlen = sha1.digest(indata, inlen, outdata); printf("outlen=%d\n", outlen); printf("outdata(hex)="); dump(outdata, outlen); delete[] outdata; } // serval times { char * outdata = new char[sha1.getCipherLen(inlen)]; sha1.update(indata, 5); sha1.update(indata+5, inlen-5); int outlen = sha1.final(outdata); printf("outlen=%d\n", outlen); printf("outdata(hex)="); dump(outdata, outlen); delete[] outdata; } } // RSA-SHA1 Sign testing. { printf("\n=======================RSA-SHA1 Sign=====================\n"); // key // N factor in RSA, aslo called modulus. const char * N = "90755611487566208138950675092879865387596685014726501531250157258482495478524769456222913843665634824684037468817980814231054856125127115894189385717148934026931120932481402379431731629550862846041784305274651476086892165805223719552575599962253392248079811268061946102234935422772131475340988882825043233323"; // e factor in RSA, aslo called public exponent. const char * e = "65537"; // d factor in RSA, aslo called private exponent const char * d = "17790520481266507102264359414044396762660094486842415203197747383916331528947124726552875080482359744765793816651732601742929364124685415229452844016482477236658413327331659722342187036963943428678684677279032263501011143882814728160215380051287503219732737197808611144507720521201393129692996926599975297921"; // input data. const char * indata = "bsmith is a good guy."; int inlen = (int)strlen(indata); printf("inlen=%d\n", inlen); printf("indata(hex)="); dump(indata, inlen); Sign sign; // private key for signer. sign.initPrivateKey(N, e, d); // sign. int maxoutlen = sign.getCipherLen(inlen); printf("maxoutlen=%d\n", maxoutlen); char * outdata = new char[maxoutlen]; int outlen = sign.sign(indata, inlen, outdata); printf("outlen=%d\n", outlen); printf("outdata(hex)="); dump(outdata, outlen); // public key for verifier. sign.initPublicKey(N, e); // verify. { bool res = sign.verify(indata, inlen, outdata, outlen); printf("result <?> true : %s\n", res?"true":"false"); } // another data. const char * indata1 = "bsmith is not a good guy."; int inlen1 = (int)strlen(indata1); { bool res = sign.verify(indata1, inlen1, outdata, outlen); printf("result <?> false : %s\n", res?"true":"false"); } delete[] outdata; } //printf("press any key to exit!"); //getchar(); { //my test unsigned long decryptSize = 0; char* decryptBuffer = (char*)getFileData(decryptPath, &decryptSize); unsigned long encryptSize = 0; char* encryptBuffer = (char*)getFileData(encryptPath, &encryptSize); printf("decryptBuffer(hex)="); dump(decryptBuffer, decryptSize); // key const char * key = "0123456789abcdef"; // iv const char * iv = "fedcba9876543210"; // init AES. AES aes; aes.init(key, 16, iv); { // decrypt. int maxinlen = aes.getPlainLen(encryptSize); char * orgdata = new char[maxinlen]; { int orglen = aes.decrypt(encryptBuffer, encryptSize, orgdata); printf("decryptWithCrypto++(hex)="); dump(orgdata, orglen); } delete [] orgdata; } printf("encryptBuffer(hex)="); dump(encryptBuffer, encryptSize); { // encrypt. int maxoutlen = aes.getCipherLen(decryptSize); char * outdata = new char[maxoutlen]; int outlen = 0; { outlen = aes.encrypt(decryptBuffer, decryptSize, outdata); printf("encryptWithCrypto++(hex)="); dump(outdata, outlen); } delete [] outdata; } delete [] decryptBuffer; delete [] encryptBuffer; } return 0; }
inline UnitVector3d operator*(const UnitVector3d& unitVector, Sign sign) { return UnitVector3d(unitVector.components() * sign.value()); }
inline std::string DebugString(Sign const& sign) { return sign.Negative() ? "-" : "+"; }