void GenerateNGon( int faces, std::vector<cCoord3>& vertices ) { //assert(faces > 2 && faces < 254); vertices.clear(); vertices.reserve(faces); //want: the closest vertex to be as far as possible //find the closest vertex, then find the next closest vertex // rotate half way between them const double center_arc = 1.0/faces; const float cos_factor = static_cast<float>(cos(center_arc * 2.0 * AKJ_PIf)); const float rotate_arc = static_cast<float>(1.0/(2.0*LeastCommonMultiple(4,faces))); const cAngleAxis rotation(rotate_arc*2.0f*AKJ_PIf, 0.0f, 0.0f, 1.0f); const float length_factor = 1.0f/cosf(rotate_arc * 2.0f * AKJ_PIf); const float sin_factor = static_cast<float>(sin(center_arc * 2.0 * AKJ_PIf)); cCoord3 out_vector(1.0f, 0.0f, 0.0f); out_vector = rotation.rotate(out_vector); vertices.push_back(length_factor*out_vector); for (int i = 2 ; i <= faces; ++i) { const cCoord3 perp_vec(-out_vector.y, out_vector.x, 0.0f); out_vector = cos_factor*out_vector; out_vector = out_vector + sin_factor*perp_vec; vertices.push_back(length_factor*out_vector); } }
const Rational Rational::operator+ (const Rational & rValue) const { long lcm = LeastCommonMultiple(rValue.denominator, denominator); long resultNumerator = (numerator * (lcm / denominator)) + (rValue.numerator * (lcm / rValue.denominator)); Rational result(resultNumerator, lcm); return result; }
void SegAlign (unsigned long Alignment, int FillVal) /* Align the PC segment to Alignment. If FillVal is -1, emit fill fragments * (the actual fill value will be determined by the linker), otherwise use * the given value. */ { unsigned char Data [4]; unsigned long CombinedAlignment; unsigned long Count; /* The segment must have the combined alignment of all separate alignments * in the source. Calculate this alignment and check it for sanity. */ CombinedAlignment = LeastCommonMultiple (ActiveSeg->Align, Alignment); if (CombinedAlignment > MAX_ALIGNMENT) { Error ("Combined alignment for active segment is %lu which exceeds %lu", CombinedAlignment, MAX_ALIGNMENT); /* Avoid creating large fills for an object file that is thrown away * later. */ Count = 1; } else { ActiveSeg->Align = CombinedAlignment; /* Output a warning for larger alignments if not suppressed */ if (CombinedAlignment > LARGE_ALIGNMENT && !LargeAlignment) { Warning (0, "Combined alignment is suspiciously large (%lu)", CombinedAlignment); } /* Calculate the number of fill bytes */ Count = AlignCount (ActiveSeg->PC, Alignment); } /* Emit the data or a fill fragment */ if (FillVal != -1) { /* User defined fill value */ memset (Data, FillVal, sizeof (Data)); while (Count) { if (Count > sizeof (Data)) { EmitData (Data, sizeof (Data)); Count -= sizeof (Data); } else { EmitData (Data, Count); Count = 0; } } } else { /* Linker defined fill value */ EmitFill (Count); } }
bool fraction::operator >(const fraction &a) const { int tmpDenominator; int cnt1,cnt2; tmpDenominator=LeastCommonMultiple(denominator,a.denominator); cnt1=tmpDenominator/denominator; cnt2=tmpDenominator/a.denominator; if(cnt1*numerator>cnt2*a.numerator) return true; else return false; }
static inline bool ReducingNotEqual(const Fractional< Natural > &left, const Fractional< Natural > &right) { Natural factor; bool result; if (left.denominator == right.denominator) { result = left.numerator != right.numerator; } else { factor = LeastCommonMultiple(left.denominator, right.denominator); if (left.denominator < right.denominator) result = left.numerator * (factor / left.denominator) != right.numerator; else result = left.numerator != right.numerator * (factor / right.denominator); } return result; }
fraction fraction::operator -(const fraction& a) const { int tmpNumerator; int tmpDenominator; int GCD; int cnt1,cnt2; tmpDenominator=LeastCommonMultiple(denominator,a.denominator); cnt1=tmpDenominator/denominator; cnt2=tmpDenominator/a.denominator; tmpNumerator=cnt1*numerator-cnt2*a.numerator; GCD=GreatestCommonDivisor(tmpNumerator,tmpDenominator); if(GCD==1) return fraction(tmpNumerator,tmpDenominator); else return fraction(tmpNumerator/GCD,tmpDenominator/GCD); }
static inline Fractional< Natural > ReducingSubtract(const Fractional< Natural > &left, const Fractional< Natural > &right) { Fractional< Natural > result; Natural factor; if (left.denominator == right.denominator) { result.numerator = left.numerator - right.numerator; result.denominator = left.denominator; } else { factor = LeastCommonMultiple(left.denominator, right.denominator); if (left.denominator < right.denominator) { factor /= left.denominator; result.numerator = left.numerator * factor - right.numerator; result.denominator = right.denominator; } else { factor /= right.denominator; result.numerator = left.numerator - right.numerator * factor; result.denominator = left.denominator; } } return Reduce(result); }
Section* ReadSection (FILE* F, ObjData* O) /* Read a section from a file */ { unsigned Name; unsigned Size; unsigned long Alignment; unsigned char Type; unsigned FragCount; Segment* S; Section* Sec; /* Read the segment data */ (void) Read32 (F); /* File size of data */ Name = MakeGlobalStringId (O, ReadVar (F)); /* Segment name */ ReadVar (F); /* Segment flags (currently unused) */ Size = ReadVar (F); /* Size of data */ Alignment = ReadVar (F); /* Alignment */ Type = Read8 (F); /* Segment type */ FragCount = ReadVar (F); /* Number of fragments */ /* Print some data */ Print (stdout, 2, "Module '%s': Found segment '%s', size = %u, alignment = %lu, type = %u\n", GetObjFileName (O), GetString (Name), Size, Alignment, Type); /* Get the segment for this section */ S = GetSegment (Name, Type, GetObjFileName (O)); /* Allocate the section we will return later */ Sec = NewSection (S, Alignment, Type); /* Remember the object file this section was from */ Sec->Obj = O; /* Set up the combined segment alignment */ if (Sec->Alignment > 1) { Alignment = LeastCommonMultiple (S->Alignment, Sec->Alignment); if (Alignment > MAX_ALIGNMENT) { Error ("Combined alignment for segment '%s' is %lu which exceeds " "%lu. Last module requiring alignment was '%s'.", GetString (Name), Alignment, MAX_ALIGNMENT, GetObjFileName (O)); } else if (Alignment >= LARGE_ALIGNMENT) { Warning ("Combined alignment for segment '%s' is suspiciously " "large (%lu). Last module requiring alignment was '%s'.", GetString (Name), Alignment, GetObjFileName (O)); } S->Alignment = Alignment; } /* Start reading fragments from the file and insert them into the section . */ while (FragCount--) { Fragment* Frag; /* Read the fragment type */ unsigned char Type = Read8 (F); /* Extract the check mask from the type */ unsigned char Bytes = Type & FRAG_BYTEMASK; Type &= FRAG_TYPEMASK; /* Handle the different fragment types */ switch (Type) { case FRAG_LITERAL: Frag = NewFragment (Type, ReadVar (F), Sec); ReadData (F, Frag->LitBuf, Frag->Size); break; case FRAG_EXPR: case FRAG_SEXPR: Frag = NewFragment (Type, Bytes, Sec); Frag->Expr = ReadExpr (F, O); break; case FRAG_FILL: /* Will allocate memory, but we don't care... */ Frag = NewFragment (Type, ReadVar (F), Sec); break; default: Error ("Unknown fragment type in module '%s', segment '%s': %02X", GetObjFileName (O), GetString (S->Name), Type); /* NOTREACHED */ return 0; } /* Read the line infos into the list of the fragment */ ReadLineInfoList (F, O, &Frag->LineInfos); /* Remember the module we had this fragment from */ Frag->Obj = O; } /* Return the section */ return Sec; }