Пример #1
0
int main(void)
{
    // 

#ifdef T_addBigInt
    string num1("123");
    string num2("4567");

    string sum = addBigInt(num1, num2);

    if (sum == "")
    {
        cerr << "error in addBigInt" << endl;
        return -1;
    }

    cout << num1 << " + " << num2 << " = " << sum << endl;
#endif 

#ifdef T_mulOneBit
    BigFloat bigNum;
    cout << "enter a big float: ";
    cin >> bigNum;
    cout << "digits = " << bigNum.digits << endl;
    cout << "exp = " << bigNum.exp << endl;

    string resu(bigNum.mulOneBit('0'));

    if ("" == resu)
    {
        cerr << "mulOneBit error"  << endl;
        return -1;
    }
    cout << "result is " << resu << endl;
#endif

#ifdef T_opMul

    BigFloat num1(100);
    BigFloat num2;
    cout << "Enter a number : ";
    cin >> num2;
    BigFloat prdt = num1 * num2;

    cout << "result is : \n" << prdt << endl;
#endif

    return 0;
}
int BigFloat::ucmp(const BigFloat &x) const{
    //  Compare function that ignores the sign.
    //  This is needed to determine which direction subtractions will go.

    //  Magnitude
    int64_t magA = exp + L;
    int64_t magB = x.exp + x.L;
    if (magA > magB)
        return 1;
    if (magA < magB)
        return -1;

    //  Compare
    int64_t mag = magA;
    while (mag >= exp || mag >= x.exp){
        uint32_t wordA = word_at(mag);
        uint32_t wordB = x.word_at(mag);
        if (wordA < wordB)
            return -1;
        if (wordA > wordB)
            return 1;
        mag--;
    }
    return 0;
}
BigFloat BigFloat::usub(const BigFloat &x,size_t p) const{
    //  Perform subtraction ignoring the sign of the two operands.

    //  "this" must be greater than or equal to x. Otherwise, the behavior
    //  is undefined.

    //  Magnitude
    int64_t magA = exp + L;
    int64_t magB = x.exp + x.L;
    int64_t top = std::max(magA,magB);
    int64_t bot = std::min(exp,x.exp);

    //  Truncate precision
    int64_t TL = top - bot;

    if (p == 0){
        //  Default value. No trunction.
        p = (size_t)TL;
    }else{
        //  Increase precision
        p += YCL_BIGFLOAT_EXTRA_PRECISION;
    }

    if (TL > (int64_t)p){
        bot = top - p;
        TL = p;
    }

    //  Compute basic fields.
    BigFloat z;
    z.sign  = sign;
    z.exp   = bot;
    z.L     = (uint32_t)TL;

    //  Allocate mantissa
    z.T = std::unique_ptr<uint32_t[]>(new uint32_t[z.L]);

    //  Subtract
    int32_t carry = 0;
    for (size_t c = 0; bot < top; bot++, c++){
        int32_t word = (int32_t)word_at(bot) - (int32_t)x.word_at(bot) - carry;
        carry = 0;
        if (word < 0){
            word += 1000000000;
            carry = 1;
        }
        z.T[c] = word;
    }

    //  Strip leading zeros
    while (z.L > 0 && z.T[z.L - 1] == 0)
        z.L--;
    if (z.L == 0){
        z.exp = 0;
        z.sign = true;
        z.T.reset();
    }

    return z;
}
Пример #4
0
inline BigFloat Epsilon<BigFloat>( const BigFloat& alpha )
{
    // NOTE: This 'precision' is the number of bits in the mantissa
    auto p = alpha.Precision();

    // epsilon = b^{-(p-1)} / 2 = 2^{-p}
    BigFloat one(1,p);
    return one >> p;
}
Пример #5
0
inline BigFloat SafeMin( const BigFloat& alpha )
{
    // TODO: Decide how to only recompute this when the precision changes
    const BigFloat one = BigFloat(1,alpha.Precision());
    const BigFloat eps = Epsilon(alpha);
    const BigFloat minVal = Min(alpha);
    const BigFloat invMax = one/Max(alpha);
    return ( invMax>minVal ? invMax*(one+eps) : minVal );
}
BigFloat invsqrt(uint32_t x,size_t p,int tds){
    //  Compute inverse square root using Newton's Method.

    //            (  r0^2 * x - 1  )
    //  r1 = r0 - (----------------) * r0
    //            (       2        )

    if (x == 0)
        throw "Divide by Zero";

    //  End of recursion. Generate starting point.
    if (p == 0){
        double val = 1. / sqrt((double)x);

        int64_t exponent = 0;

        //  Scale
        while (val < 1000000000.){
            val *= 1000000000.;
            exponent--;
        }

        //  Rebuild a BigFloat.
        uint64_t val64 = (uint64_t)val;

        BigFloat out;
        out.sign = true;

        out.T = std::unique_ptr<uint32_t[]>(new uint32_t[2]);
        out.T[0] = (uint32_t)(val64 % 1000000000);
        out.T[1] = (uint32_t)(val64 / 1000000000);
        out.L = 2;
        out.exp = exponent;

        return out;
    }

    //  Half the precision
    size_t s = p / 2 + 1;
    if (p == 1) s = 0;
    if (p == 2) s = 1;

    //  Recurse at half the precision
    BigFloat T = invsqrt(x,s,tds);

    BigFloat temp = T.mul(T,p);     //  r0^2
    temp = temp.mul(x,p,tds);       //  r0^2 * x
    temp = temp.sub(BigFloat(1),p); //  r0^2 * x - 1
    temp = temp.mul(500000000);         //  (r0^2 * x - 1) / 2
    temp.exp--;
    temp = temp.mul(T,p,tds);       //  (r0^2 * x - 1) / 2 * r0
    return T.sub(temp,p);           //  r0 - (r0^2 * x - 1) / 2 * r0
}
BigFloat BigFloat::sub(const BigFloat &x,size_t p) const{
    //  Subtraction

    //  The target precision is p.
    //  If (p = 0), then no truncation is done. The entire operation is done
    //  at maximum precision with no data loss.

    //  Different sign. Add.
    if (sign != x.sign)
        return uadd(x,p);

    //  this > x
    if (ucmp(x) > 0)
        return usub(x,p);

    //  this < x
    BigFloat z = x.usub(*this,p);
    z.negate();
    return z;
}
Пример #8
0
int main()
{
	BigFloat *sum;
	sum = new BigFloat(0.0);
	
	for ( int i = 1; i <= 100 ; i ++)
	{
		BigFloat index(1.0);
		BigFloat temp((double)i);
		if ( 0 == index.divide(&index, &temp))
			sum->add(sum,&index);
		else
		{
			printf("error");
			exit(1);
		}
	}
	sum->printAll();
	sum->print_fraction_portion_in_decimal(1000,NULL);
}
BigFloat BigFloat::uadd(const BigFloat &x,size_t p) const{
    //  Perform addition ignoring the sign of the two operands.

    //  Magnitude
    int64_t magA = exp + L;
    int64_t magB = x.exp + x.L;
    int64_t top = std::max(magA,magB);
    int64_t bot = std::min(exp,x.exp);

    //  Target length
    int64_t TL = top - bot;

    if (p == 0){
        //  Default value. No trunction.
        p = (size_t)TL;
    }else{
        //  Increase precision
        p += YCL_BIGFLOAT_EXTRA_PRECISION;
    }

    //  Perform precision truncation.
    if (TL > (int64_t)p){
        bot = top - p;
        TL = p;
    }

    //  Compute basic fields.
    BigFloat z;
    z.sign  = sign;
    z.exp   = bot;
    z.L     = (uint32_t)TL;

    //  Allocate mantissa
    z.T = std::unique_ptr<uint32_t[]>(new uint32_t[z.L + 1]);

    //  Add
    uint32_t carry = 0;
    for (size_t c = 0; bot < top; bot++, c++){
        uint32_t word = word_at(bot) + x.word_at(bot) + carry;
        carry = 0;
        if (word >= 1000000000){
            word -= 1000000000;
            carry = 1;
        }
        z.T[c] = word;
    }

    //  Carry out
    if (carry != 0){
        z.T[z.L++] = 1;
    }

    return z;
}
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
//  Pi
void Pi_BSR(BigFloat &P,BigFloat &Q,BigFloat &R,uint32_t a,uint32_t b,size_t p){
    //  Binary Splitting recursion for the Chudnovsky Formula.

    if (b - a == 1){
        //  P = (13591409 + 545140134 b)(2b-1)(6b-5)(6b-1) (-1)^b
        P = BigFloat(b).mul(545140134);
        P = P.add(BigFloat(13591409));
        P = P.mul(2*b - 1);
        P = P.mul(6*b - 5);
        P = P.mul(6*b - 1);
        if (b % 2 == 1)
            P.negate();

        //  Q = 10939058860032000 * b^3
        Q = BigFloat(b);
        Q = Q.mul(Q).mul(Q).mul(26726400).mul(409297880);

        //  R = (2b-1)(6b-5)(6b-1)
        R = BigFloat(2*b - 1);
        R = R.mul(6*b - 5);
        R = R.mul(6*b - 1);

        return;
    }

    uint32_t m = (a + b) / 2;

    BigFloat P0,Q0,R0,P1,Q1,R1;
    Pi_BSR(P0,Q0,R0,a,m,p);
    Pi_BSR(P1,Q1,R1,m,b,p);

    P = P0.mul(Q1,p).add(P1.mul(R0,p),p);
    Q = Q0.mul(Q1,p);
    R = R0.mul(R1,p);
}
Пример #11
0
bool GaussElimination::changeValuesInRowByBigFloat(vector<vector<BigFloat>>& matrix, int indexRow)
{
	if( matrix[indexRow][indexRow].compare( &BigFloat(0.0) ) != 0 ) return true;

	// wenn i.zeile zahl in spalte i = 0, tausche mit zeile darunter!!, wo zahl in i.spalte != 0 -> falls nicht da, gs nicht lösbar
	for(unsigned int rowCounter = indexRow+1; rowCounter < row; ++rowCounter)
	{
		BigFloat value = matrix[rowCounter][indexRow];
		if(value.compare( &BigFloat(0.0) ) != 0 )
		{
			// tausche reihen
			for(unsigned int i = 0; i <= col; ++i) //zusätzliche spalte angefügt durch vector
			{
				BigFloat currowValue = matrix[indexRow][i];
				BigFloat changeValue = matrix[rowCounter][i];
				matrix[indexRow][i] = changeValue;
				matrix[rowCounter][i] = currowValue;
			}
			return true;
		}
	}

	return false;
}
Пример #12
0
	// Zoom vers la cible du clic
	static void clicGauche(SDL_Event& event, Affichage* disp)
	{

		// Calcul de la position du clic dans le plan complexe
		float x = disp->center.x + disp->scale*(((float)event.motion.x) / WIDTH - 0.5f);
		float y = disp->center.y + disp->scale*(((float)event.motion.y) / HEIGHT - 0.5f);

		// MAJ de la position du nouveau centre dans le plan complexe
		if (INTERACTIVE) {
			disp->center.x = x + (disp->center.x - x) * ZOOM_FACTOR;
			disp->center.y = y + (disp->center.y - y) * ZOOM_FACTOR;
			updateBigCenter(event, true);
		}
		

		// MAJ de l'echelle
		disp->scale *= ZOOM_FACTOR;
		//BigFloat zoomFactor(true, 0, 0x80000000, 0, 0);
		BigFloat temp, temp2;
		BigFloat::mult(ZOOM_FACTOR, *bigScale, temp);
		bigScale->reset();
		temp2.copy(*bigScale);
		BigFloat::add(temp, temp2, *bigScale);
		
		//Nouveau calcul de la fractale avec chrono
		disp->start = chrono::system_clock::now();

		if (GPU && BIG_FLOAT_SIZE == 0)
			affichageGPU(disp);
		else if (GPU)
			computeBigMandelGPU(disp, xCenter->pos, xCenter->decimals, yCenter->pos, yCenter->decimals, bigScale->decimals);
		else
			if (BIG_FLOAT_SIZE == 0)
				computeMandel(disp->pixels, disp->center, disp->scale);
			else {
				computeBigMandel(disp->pixels, *xCenter, *yCenter, *bigScale);
			}

		disp->end = chrono::system_clock::now();
		disp->duration = disp->end - disp->start;
		cout << "Frame computing time : " << disp->duration.count() << endl;
		//cout << "Frame computing scale : " << disp->scale << endl;
		
		// Affichage de la fractale
		disp->dessin();
	}
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
//  Pi
void Pi_BSR(BigFloat &P,BigFloat &Q,BigFloat &R,uint32_t a,uint32_t b,size_t p,int tds = 1){
    //  Binary Splitting recursion for the Chudnovsky Formula.

    if (b - a == 1){
        //  P = (13591409 + 545140134 b)(2b-1)(6b-5)(6b-1) (-1)^b
        P = BigFloat(b).mul(545140134);
        P = P.add(BigFloat(13591409));
        P = P.mul(2*b - 1);
        P = P.mul(6*b - 5);
        P = P.mul(6*b - 1);
        if (b % 2 == 1)
            P.negate();

        //  Q = 10939058860032000 * b^3
        Q = BigFloat(b);
        Q = Q.mul(Q).mul(Q).mul(26726400).mul(409297880);

        //  R = (2b-1)(6b-5)(6b-1)
        R = BigFloat(2*b - 1);
        R = R.mul(6*b - 5);
        R = R.mul(6*b - 1);

        return;
    }

    uint32_t m = (a + b) / 2;

    BigFloat P0,Q0,R0,P1,Q1,R1;

    if (b - a < 1000 || tds < 2){
        //  No more threads.
        Pi_BSR(P0,Q0,R0,a,m,p);
        Pi_BSR(P1,Q1,R1,m,b,p);
    }else{
        //  Run sub-recursions in parallel.
        int tds0 = tds / 2;
        int tds1 = tds - tds0;
#pragma omp parallel num_threads(2)
        {
            int tid = omp_get_thread_num();
            if (tid == 0){
                Pi_BSR(P0,Q0,R0,a,m,p,tds0);
            }
            if (tid != 0 || omp_get_num_threads() < 2){
                Pi_BSR(P1,Q1,R1,m,b,p,tds1);
            }
        }
    }

    P = P0.mul(Q1,p,tds).add(P1.mul(R0,p,tds),p);
    Q = Q0.mul(Q1,p,tds);
    R = R0.mul(R1,p,tds);
}
BigFloat BigFloat::add(const BigFloat &x,size_t p) const{
    //  Addition

    //  The target precision is p.
    //  If (p = 0), then no truncation is done. The entire operation is done
    //  at maximum precision with no data loss.

    //  Same sign. Add.
    if (sign == x.sign)
        return uadd(x,p);

    //  this > x
    if (ucmp(x) > 0)
        return usub(x,p);

    //  this < x
    return x.usub(*this,p);
}
void ComputeFloatSession<wtype>::write_digits(const BigFloat<wtype>& x, const std::string& name, const std::string& algorithm){
    std::string dec_name, hex_name;
    if (algorithm.empty()){
        dec_name = name + " - Dec.txt";
        hex_name = name + " - Hex.txt";
    }else{
        dec_name = name + " - Dec - " + algorithm + ".txt";
        hex_name = name + " - Hex - " + algorithm + ".txt";
    }

    //  Special Case: If the number is close to one, don't count the digits in
    //  front of the decimal place. This keeps the behavior consistent with
    //  y-cruncher and other Pi programs that start counting digits after the
    //  decimal place.
    upL_t dec_digits = m_dec;
    upL_t hex_digits = m_hex;
    if (x.get_mag() == 1){
        wtype top_word = x[0];
        dec_digits += std::to_string(top_word).size();
        while (top_word != 0){
            top_word >>= 4;
            hex_digits++;
        }
    }
BigFloat BigFloat::rcp(size_t p,int tds) const{
    //  Compute reciprocal using Newton's Method.

    //  r1 = r0 - (r0 * x - 1) * r0

    if (L == 0)
        throw "Divide by Zero";

    //  Collect operand
    int64_t Aexp = exp;
    size_t AL = L;
    uint32_t *AT = T.get();

    //  End of recursion. Generate starting point.
    if (p == 0){
        //  Truncate precision to 3.
        p = 3;
        if (AL > p){
            size_t chop = AL - p;
            AL = p;
            Aexp += chop;
            AT += chop;
        }

        //  Convert number to floating-point.
        double val = AT[0];
        if (AL >= 2)
            val += AT[1] * 1000000000.;
        if (AL >= 3)
            val += AT[2] * 1000000000000000000.;

        //  Compute reciprocal.
        val = 1. / val;
        Aexp = -Aexp;

        //  Scale
        while (val < 1000000000.){
            val *= 1000000000.;
            Aexp--;
        }

        //  Rebuild a BigFloat.
        uint64_t val64 = (uint64_t)val;

        BigFloat out;
        out.sign = sign;

        out.T = std::unique_ptr<uint32_t[]>(new uint32_t[2]);
        out.T[0] = (uint32_t)(val64 % 1000000000);
        out.T[1] = (uint32_t)(val64 / 1000000000);
        out.L = 2;
        out.exp = Aexp;

        return out;
    }

    //  Half the precision
    size_t s = p / 2 + 1;
    if (p == 1) s = 0;
    if (p == 2) s = 1;

    //  Recurse at half the precision
    BigFloat T = rcp(s,tds);

    //  r1 = r0 - (r0 * x - 1) * r0
    return T.sub(this->mul(T,p,tds).sub(BigFloat(1),p).mul(T,p,tds),p);
}
Пример #17
0
inline Int NumMantissaBits<BigFloat>( const BigFloat& alpha )
{ return alpha.Precision(); }
Пример #18
0
inline bool IsFinite( const BigFloat& alpha )
{ return mpfr_number_p( alpha.LockedPointer() ) != 0; }
Пример #19
0
inline BigFloat Infinity<BigFloat>( const BigFloat& alpha )
{
    BigFloat inf(0,alpha.Precision());
    mpfr_set_inf( inf.Pointer(), 1 );
    return inf;
}
Пример #20
0
// freebayes main
int main (int argc, char *argv[]) {

    // install segfault handler
    signal(SIGSEGV, segfaultHandler);

    AlleleParser* parser = new AlleleParser(argc, argv);
    Parameters& parameters = parser->parameters;
    list<Allele*> alleles;

    Samples samples;

    ostream& out = *(parser->output);

    Bias observationBias;
    if (!parameters.alleleObservationBiasFile.empty()) {
        observationBias.open(parameters.alleleObservationBiasFile);
    }

    Contamination contaminationEstimates(0.5+parameters.probContamination, parameters.probContamination);
    if (!parameters.contaminationEstimateFile.empty()) {
        contaminationEstimates.open(parameters.contaminationEstimateFile);
    }

    // this can be uncommented to force operation on a specific set of genotypes
    vector<Allele> allGenotypeAlleles;
    allGenotypeAlleles.push_back(genotypeAllele(ALLELE_GENOTYPE, "A", 1));
    allGenotypeAlleles.push_back(genotypeAllele(ALLELE_GENOTYPE, "T", 1));
    allGenotypeAlleles.push_back(genotypeAllele(ALLELE_GENOTYPE, "G", 1));
    allGenotypeAlleles.push_back(genotypeAllele(ALLELE_GENOTYPE, "C", 1));

    int allowedAlleleTypes = ALLELE_REFERENCE;
    if (parameters.allowSNPs) {
        allowedAlleleTypes |= ALLELE_SNP;
    }
    if (parameters.allowIndels) {
        allowedAlleleTypes |= ALLELE_INSERTION;
        allowedAlleleTypes |= ALLELE_DELETION;
    }
    if (parameters.allowMNPs) {
        allowedAlleleTypes |= ALLELE_MNP;
    }
    if (parameters.allowComplex) {
        allowedAlleleTypes |= ALLELE_COMPLEX;
    }

    // output VCF header
    if (parameters.output == "vcf") {
        out << parser->variantCallFile.header << endl;
    }

    Allele nullAllele = genotypeAllele(ALLELE_NULL, "N", 1, "1N");

    unsigned long total_sites = 0;
    unsigned long processed_sites = 0;

    while (parser->getNextAlleles(samples, allowedAlleleTypes)) {

        ++total_sites;

        DEBUG2("at start of main loop");

        // don't process non-ATGC's in the reference
        string cb = parser->currentReferenceBaseString();
        if (cb != "A" && cb != "T" && cb != "C" && cb != "G") {
            DEBUG2("current reference base is N");
            continue;
        }

        if (parameters.trace) {
            for (Samples::iterator s = samples.begin(); s != samples.end(); ++s) {
                const string& name = s->first;
                for (Sample::iterator g = s->second.begin(); g != s->second.end(); ++g) {
                    vector<Allele*>& group = g->second;
                    for (vector<Allele*>::iterator a = group.begin(); a != group.end(); ++a) {
                        Allele& allele = **a;
                        parser->traceFile << parser->currentSequenceName << "," << (long unsigned int) parser->currentPosition + 1  
                                          << ",allele," << name << "," << allele.readID << "," << allele.base() << ","
                                          << allele.currentQuality() << "," << allele.mapQuality << endl;
                    }
                }
            }
            DEBUG2("after trace generation");
        }

        if (!parser->inTarget()) {
            DEBUG("position: " << parser->currentSequenceName << ":" << (long unsigned int) parser->currentPosition + 1
                  << " is not inside any targets, skipping");
            continue;
        }

        int coverage = countAlleles(samples);

        DEBUG("position: " << parser->currentSequenceName << ":" << (long unsigned int) parser->currentPosition + 1 << " coverage: " << coverage);

        if (!parser->hasInputVariantAllelesAtCurrentPosition()) {
            // skips 0-coverage regions
            if (coverage == 0) {
                DEBUG("no alleles left at this site after filtering");
                continue;
            } else if (coverage < parameters.minCoverage) {
                DEBUG("post-filtering coverage of " << coverage << " is less than --min-coverage of " << parameters.minCoverage);
                continue;
            } else if (parameters.onlyUseInputAlleles) {
                DEBUG("no input alleles, but using only input alleles for analysis, skipping position");
                continue;
            }

            DEBUG2("coverage " << parser->currentSequenceName << ":" << parser->currentPosition << " == " << coverage);

            // establish a set of possible alternate alleles to evaluate at this location

            if (!parameters.reportMonomorphic
                && !sufficientAlternateObservations(samples, parameters.minAltCount, parameters.minAltFraction)) {
                DEBUG("insufficient alternate observations");
                continue;
            }
            if (parameters.reportMonomorphic) {
                DEBUG("calling at site even though there are no alternate observations");
            }
        } else {
            /*
            cerr << "has input variants at " << parser->currentSequenceName << ":" << parser->currentPosition << endl;
            vector<Allele>& inputs = parser->inputVariantAlleles[parser->currentPosition];
            for (vector<Allele>::iterator a = inputs.begin(); a != inputs.end(); ++a) {
                cerr << *a << endl;
            }
            */
        }

        // to ensure proper ordering of output stream
        vector<string> sampleListPlusRef;

        for (vector<string>::iterator s = parser->sampleList.begin(); s != parser->sampleList.end(); ++s) {
            sampleListPlusRef.push_back(*s);
        }
        if (parameters.useRefAllele) {
            sampleListPlusRef.push_back(parser->currentSequenceName);
        }

        // establish genotype alleles using input filters
        map<string, vector<Allele*> > alleleGroups;
        groupAlleles(samples, alleleGroups);
        DEBUG2("grouped alleles by equivalence");

        vector<Allele> genotypeAlleles = parser->genotypeAlleles(alleleGroups, samples, parameters.onlyUseInputAlleles);

        // always include the reference allele as a possible genotype, even when we don't include it by default
        if (!parameters.useRefAllele) {
            vector<Allele> refAlleleVector;
            refAlleleVector.push_back(genotypeAllele(ALLELE_REFERENCE, string(1, parser->currentReferenceBase), 1, "1M"));
            genotypeAlleles = alleleUnion(genotypeAlleles, refAlleleVector);
        }

        map<string, vector<Allele*> > partialObservationGroups;
        map<Allele*, set<Allele*> > partialObservationSupport;

        // build haplotype alleles matching the current longest allele (often will do nothing)
        // this will adjust genotypeAlleles if changes are made
        DEBUG("building haplotype alleles, currently there are " << genotypeAlleles.size() << " genotype alleles");
        DEBUG(genotypeAlleles);
        parser->buildHaplotypeAlleles(genotypeAlleles,
                                      samples,
                                      alleleGroups,
                                      partialObservationGroups,
                                      partialObservationSupport,
                                      allowedAlleleTypes);
        DEBUG("built haplotype alleles, now there are " << genotypeAlleles.size() << " genotype alleles");
        DEBUG(genotypeAlleles);

        string referenceBase = parser->currentReferenceHaplotype();


        /* for debugging
        for (Samples::iterator s = samples.begin(); s != samples.end(); ++s) {
            string sampleName = s->first;
            Sample& sample = s->second;
            cerr << sampleName << ": " << sample << endl;
        }
        */

        // re-calculate coverage, as this could change now that we've built haplotype alleles
        coverage = countAlleles(samples);

        // estimate theta using the haplotype length
        long double theta = parameters.TH * parser->lastHaplotypeLength;

        // if we have only one viable allele, we don't have evidence for variation at this site
        if (!parser->hasInputVariantAllelesAtCurrentPosition() && !parameters.reportMonomorphic && genotypeAlleles.size() <= 1 && genotypeAlleles.front().isReference()) {
            DEBUG("no alternate genotype alleles passed filters at " << parser->currentSequenceName << ":" << parser->currentPosition);
            continue;
        }
        DEBUG("genotype alleles: " << genotypeAlleles);

        // add the null genotype
        bool usingNull = false;
        if (parameters.excludeUnobservedGenotypes && genotypeAlleles.size() > 2) {
            genotypeAlleles.push_back(nullAllele);
            usingNull = true;
        }

        ++processed_sites;

        // generate possible genotypes

        // for each possible ploidy in the dataset, generate all possible genotypes
        vector<int> ploidies = parser->currentPloidies(samples);
        map<int, vector<Genotype> > genotypesByPloidy = getGenotypesByPloidy(ploidies, genotypeAlleles);
        int numCopiesOfLocus = parser->copiesOfLocus(samples);


        DEBUG2("generated all possible genotypes:");
        if (parameters.debug2) {
            for (map<int, vector<Genotype> >::iterator s = genotypesByPloidy.begin(); s != genotypesByPloidy.end(); ++s) {
                vector<Genotype>& genotypes = s->second;
                for (vector<Genotype>::iterator g = genotypes.begin(); g != genotypes.end(); ++g) {
                    DEBUG2(*g);
                }
            }
        }

        // get estimated allele frequencies using sum of estimated qualities
        map<string, double> estimatedAlleleFrequencies = samples.estimatedAlleleFrequencies();
        double estimatedMaxAlleleFrequency = 0;
        double estimatedMaxAlleleCount = 0;
        double estimatedMajorFrequency = estimatedAlleleFrequencies[referenceBase];
        if (estimatedMajorFrequency < 0.5) estimatedMajorFrequency = 1-estimatedMajorFrequency;
        double estimatedMinorFrequency = 1-estimatedMajorFrequency;
        //cerr << "num copies of locus " << numCopiesOfLocus << endl;
        int estimatedMinorAllelesAtLocus = max(1, (int) ceil((double) numCopiesOfLocus * estimatedMinorFrequency));
        //cerr << "estimated minor frequency " << estimatedMinorFrequency << endl;
        //cerr << "estimated minor count " << estimatedMinorAllelesAtLocus << endl;
        

        Results results;
        map<string, vector<vector<SampleDataLikelihood> > > sampleDataLikelihoodsByPopulation;
        map<string, vector<vector<SampleDataLikelihood> > > variantSampleDataLikelihoodsByPopulation;
        map<string, vector<vector<SampleDataLikelihood> > > invariantSampleDataLikelihoodsByPopulation;

        map<string, int> inputAlleleCounts;
        int inputLikelihoodCount = 0;

        DEBUG2("calculating data likelihoods");
        // calculate data likelihoods
        //for (Samples::iterator s = samples.begin(); s != samples.end(); ++s) {
        for (vector<string>::iterator n = parser->sampleList.begin(); n != parser->sampleList.end(); ++n) {

            //string sampleName = s->first;
            string& sampleName = *n;
            //DEBUG2("sample: " << sampleName);
            //Sample& sample = s->second;
            if (samples.find(sampleName) == samples.end()
                && !(parser->hasInputVariantAllelesAtCurrentPosition()
                     || parameters.reportMonomorphic)) {
                continue;
            }
            Sample& sample = samples[sampleName];
            vector<Genotype>& genotypes = genotypesByPloidy[parser->currentSamplePloidy(sampleName)];
            vector<Genotype*> genotypesWithObs;
            for (vector<Genotype>::iterator g = genotypes.begin(); g != genotypes.end(); ++g) {
                if (parameters.excludePartiallyObservedGenotypes) {
                    if (g->sampleHasSupportingObservationsForAllAlleles(sample)) {
                        genotypesWithObs.push_back(&*g);
                    }
                } else if (parameters.excludeUnobservedGenotypes && usingNull) {
                    if (g->sampleHasSupportingObservations(sample)) {
                        //cerr << sampleName << " has suppporting obs for " << *g << endl;
                        genotypesWithObs.push_back(&*g);
                    } else if (g->hasNullAllele() && g->homozygous) {
                        // this genotype will never be added if we are running in observed-only mode, but
                        // we still need it for consistency
                        genotypesWithObs.push_back(&*g);
                    }
                } else {
                    genotypesWithObs.push_back(&*g);
                }
            }

            // skip this sample if we have no observations supporting any of the genotypes we are going to evaluate
            if (genotypesWithObs.empty()) {
                continue;
            }

            vector<pair<Genotype*, long double> > probs
                = probObservedAllelesGivenGenotypes(sample, genotypesWithObs,
                                                    parameters.RDF, parameters.useMappingQuality,
                                                    observationBias, parameters.standardGLs,
                                                    genotypeAlleles,
                                                    contaminationEstimates,
                                                    estimatedAlleleFrequencies);
            
#ifdef VERBOSE_DEBUG
            if (parameters.debug2) {
                for (vector<pair<Genotype*, long double> >::iterator p = probs.begin(); p != probs.end(); ++p) {
                    cerr << parser->currentSequenceName << "," << (long unsigned int) parser->currentPosition + 1 << ","
                         << sampleName << ",likelihood," << *(p->first) << "," << p->second << endl;
                }
            }
#endif

            Result& sampleData = results[sampleName];
            sampleData.name = sampleName;
            sampleData.observations = &sample;
            for (vector<pair<Genotype*, long double> >::iterator p = probs.begin(); p != probs.end(); ++p) {
                sampleData.push_back(SampleDataLikelihood(sampleName, &sample, p->first, p->second, 0));
            }

            sortSampleDataLikelihoods(sampleData);

            string& population = parser->samplePopulation[sampleName];
            vector<vector<SampleDataLikelihood> >& sampleDataLikelihoods = sampleDataLikelihoodsByPopulation[population];
            vector<vector<SampleDataLikelihood> >& variantSampleDataLikelihoods = variantSampleDataLikelihoodsByPopulation[population];
            vector<vector<SampleDataLikelihood> >& invariantSampleDataLikelihoods = invariantSampleDataLikelihoodsByPopulation[population];

            if (parameters.genotypeVariantThreshold != 0) {
                if (sampleData.size() > 1
                    && abs(sampleData.at(1).prob - sampleData.front().prob)
                    < parameters.genotypeVariantThreshold) {
                    variantSampleDataLikelihoods.push_back(sampleData);
                } else {
                    invariantSampleDataLikelihoods.push_back(sampleData);
                }
            } else {
                variantSampleDataLikelihoods.push_back(sampleData);
            }
            sampleDataLikelihoods.push_back(sampleData);

            DEBUG2("obtaining genotype likelihoods input from VCF");
            int prevcount = sampleDataLikelihoods.size();
            parser->addCurrentGenotypeLikelihoods(genotypesByPloidy, sampleDataLikelihoods);
            // add these sample data likelihoods to 'invariant' likelihoods
            inputLikelihoodCount += sampleDataLikelihoods.size() - prevcount;
            parser->addCurrentGenotypeLikelihoods(genotypesByPloidy, invariantSampleDataLikelihoods);

        }

        // if there are not any input GLs, attempt to use the input ACs
        if (inputLikelihoodCount == 0) {
            parser->getInputAlleleCounts(genotypeAlleles, inputAlleleCounts);
        }

        DEBUG2("finished calculating data likelihoods");


        // this section is a hack to make output of trace identical to BamBayes trace
        // and also outputs the list of samples
        vector<bool> samplesWithData;
        if (parameters.trace) {
            parser->traceFile << parser->currentSequenceName << "," << (long unsigned int) parser->currentPosition + 1 << ",samples,";
            for (vector<string>::iterator s = sampleListPlusRef.begin(); s != sampleListPlusRef.end(); ++s) {
                if (parameters.trace) parser->traceFile << *s << ":";
                Results::iterator r = results.find(*s);
                if (r != results.end()) {
                    samplesWithData.push_back(true);
                } else {
                    samplesWithData.push_back(false);
                }
            }
            parser->traceFile << endl;
        }

        // if somehow we get here without any possible sample genotype likelihoods, bail out
        bool hasSampleLikelihoods = false;
        for (map<string, vector<vector<SampleDataLikelihood> > >::iterator s = sampleDataLikelihoodsByPopulation.begin(); s != sampleDataLikelihoodsByPopulation.end(); ++s) {
            if (!s->second.empty()) {
                hasSampleLikelihoods = true;
                break;
            }
        }
        if (!hasSampleLikelihoods) {
            continue;
        }

        DEBUG2("calulating combo posteriors over " << parser->populationSamples.size() << " populations");

        // XXX
        // TODO skip these steps in the case that there is only one population?


        // we provide p(var|data), or the probability that the location has
        // variation between individuals relative to the probability that it
        // has no variation
        //
        // in other words:
        // p(var|d) = 1 - p(AA|d) - p(TT|d) - P(GG|d) - P(CC|d)
        //
        // the approach is go through all the homozygous combos
        // and then subtract this from 1... resolving p(var|d)

        BigFloat pVar = 1.0;
        BigFloat pHom = 0.0;

        long double bestComboOddsRatio = 0;

        GenotypeCombo bestCombo; // = NULL;

        // what a hack...
        /*
        if (parameters.trace) {
            for (list<GenotypeCombo>::iterator gc = genotypeCombos.begin(); gc != genotypeCombos.end(); ++gc) {
                vector<Genotype*> comboGenotypes;
                for (GenotypeCombo::iterator g = gc->begin(); g != gc->end(); ++g)
                    comboGenotypes.push_back((*g)->genotype);
                long double posteriorProb = gc->posteriorProb;
                long double dataLikelihoodln = gc->probObsGivenGenotypes;
                long double priorln = gc->posteriorProb;
                long double priorlnG_Af = gc->priorProbG_Af;
                long double priorlnAf = gc->priorProbAf;
                long double priorlnBin = gc->priorProbObservations;

                parser->traceFile << parser->currentSequenceName << "," << (long unsigned int) parser->currentPosition + 1 << ",genotypecombo,";

                int j = 0;
                GenotypeCombo::iterator i = gc->begin();
                for (vector<bool>::iterator d = samplesWithData.begin(); d != samplesWithData.end(); ++d) {
                    if (*d) {
                        parser->traceFile << IUPAC(*(*i)->genotype);
                        ++i;
                    } else {
                        parser->traceFile << "?";
                    }
                }
                // TODO cleanup this and above
                parser->traceFile 
                    << "," << dataLikelihoodln
                    << "," << priorln
                    << "," << priorlnG_Af
                    << "," << priorlnAf
                    << "," << priorlnBin
                    << "," << posteriorProb
                    << "," << safe_exp(posteriorProb - posteriorNormalizer)
                    << endl;
            }
        }
        */

        // the second clause guards against float underflow causing us not to output a position
        // practically, parameters.PVL == 0 means "report all genotypes which pass our input filters"


        GenotypeCombo bestGenotypeComboByMarginals;
        vector<vector<SampleDataLikelihood> > allSampleDataLikelihoods;

        DEBUG("searching genotype space");

        // resample the posterior, this time without bounds on the
        // samples we vary, ensuring that we can generate marginals for
        // all sample/genotype combinations

        //SampleDataLikelihoods marginalLikelihoods = sampleDataLikelihoods;  // heavyweight copy...
        map<string, list<GenotypeCombo> > genotypeCombosByPopulation;
        int genotypingTotalIterations = 0; // tally total iterations required to reach convergence
        map<string, list<GenotypeCombo> > glMaxCombos;

        for (map<string, SampleDataLikelihoods>::iterator p = sampleDataLikelihoodsByPopulation.begin(); p != sampleDataLikelihoodsByPopulation.end(); ++p) {

            const string& population = p->first;
            SampleDataLikelihoods& sampleDataLikelihoods = p->second;
            list<GenotypeCombo>& populationGenotypeCombos = genotypeCombosByPopulation[population];

            DEBUG2("genqerating banded genotype combinations from " << sampleDataLikelihoods.size() << " sample genotypes in population " << population);

            // cap the number of iterations at 2 x the number of alternate alleles
            // max it at parameters.genotypingMaxIterations iterations, min at 10
            int itermax = min(max(10, 2 * estimatedMinorAllelesAtLocus), parameters.genotypingMaxIterations);
            //int itermax = parameters.genotypingMaxIterations;

            // XXX HACK
            // passing 0 for bandwidth and banddepth means "exhaustive local search"
            // this produces properly normalized GQ's at polyallelic sites
            int adjustedBandwidth = 0;
            int adjustedBanddepth = 0;
            // however, this can lead to huge performance problems at complex sites,
            // so we implement this hack...
            if (parameters.genotypingMaxBandDepth > 0 &&
                genotypeAlleles.size() > parameters.genotypingMaxBandDepth) {
                adjustedBandwidth = 1;
                adjustedBanddepth = parameters.genotypingMaxBandDepth;
            }

            GenotypeCombo nullCombo;
            SampleDataLikelihoods nullSampleDataLikelihoods;

            // this is the genotype-likelihood maximum
            if (parameters.reportGenotypeLikelihoodMax) {
                GenotypeCombo comboKing;
                vector<int> initialPosition;
                initialPosition.assign(sampleDataLikelihoods.size(), 0);
                SampleDataLikelihoods nullDataLikelihoods; // dummy variable
                makeComboByDatalLikelihoodRank(comboKing,
                                               initialPosition,
                                               sampleDataLikelihoods,
                                               nullDataLikelihoods,
                                               inputAlleleCounts,
                                               theta,
                                               parameters.pooledDiscrete,
                                               parameters.ewensPriors,
                                               parameters.permute,
                                               parameters.hwePriors,
                                               parameters.obsBinomialPriors,
                                               parameters.alleleBalancePriors,
                                               parameters.diffusionPriorScalar);

                glMaxCombos[population].push_back(comboKing);
            }

            // search much longer for convergence
            convergentGenotypeComboSearch(
                populationGenotypeCombos,
                nullCombo,
                sampleDataLikelihoods, // vary everything
                sampleDataLikelihoods,
                nullSampleDataLikelihoods,
                samples,
                genotypeAlleles,
                inputAlleleCounts,
                adjustedBandwidth,
                adjustedBanddepth,
                theta,
                parameters.pooledDiscrete,
                parameters.ewensPriors,
                parameters.permute,
                parameters.hwePriors,
                parameters.obsBinomialPriors,
                parameters.alleleBalancePriors,
                parameters.diffusionPriorScalar,
                itermax,
                genotypingTotalIterations,
                true); // add homozygous combos
                // ^^ combo results are sorted by default
        }

        // generate the GL max combo
        GenotypeCombo glMax;
        if (parameters.reportGenotypeLikelihoodMax) {
            list<GenotypeCombo> glMaxGenotypeCombos;
            combinePopulationCombos(glMaxGenotypeCombos, glMaxCombos);
            glMax = glMaxGenotypeCombos.front();
        }

        // accumulate combos from independently-calculated populations into the list of combos
        list<GenotypeCombo> genotypeCombos; // build new combos into this list
        combinePopulationCombos(genotypeCombos, genotypeCombosByPopulation);
        // TODO factor out the following blocks as they are repeated from above

        // re-get posterior normalizer
        vector<long double> comboProbs;
        for (list<GenotypeCombo>::iterator gc = genotypeCombos.begin(); gc != genotypeCombos.end(); ++gc) {
            comboProbs.push_back(gc->posteriorProb);
        }
        long double posteriorNormalizer = logsumexp_probs(comboProbs);

        // recalculate posterior normalizer
        pVar = 1.0;
        pHom = 0.0;
        // calculates pvar and gets the best het combo
        for (list<GenotypeCombo>::iterator gc = genotypeCombos.begin(); gc != genotypeCombos.end(); ++gc) {
            if (gc->isHomozygous()
                && (parameters.useRefAllele
                    || !parameters.useRefAllele && gc->alleles().front() == referenceBase)) {
                pVar -= big_exp(gc->posteriorProb - posteriorNormalizer);
                pHom += big_exp(gc->posteriorProb - posteriorNormalizer);
            }
        }

        // report the maximum a posteriori estimate
        // unless we're reporting the GL maximum
        if (!parameters.reportGenotypeLikelihoodMax) {
            bestCombo = genotypeCombos.front();
        } else {
            bestCombo = glMax;
        }

        DEBUG2("best combo: " << bestCombo);

        // odds ratio between the first and second-best combinations
        if (genotypeCombos.size() > 1) {
            bestComboOddsRatio = genotypeCombos.front().posteriorProb - (++genotypeCombos.begin())->posteriorProb;
        }

        if (parameters.calculateMarginals) {
            // make a combined, all-populations sample data likelihoods vector to accumulate marginals
            SampleDataLikelihoods allSampleDataLikelihoods;
            for (map<string, SampleDataLikelihoods>::iterator p = sampleDataLikelihoodsByPopulation.begin(); p != sampleDataLikelihoodsByPopulation.end(); ++p) {
                SampleDataLikelihoods& sdls = p->second;
                allSampleDataLikelihoods.reserve(allSampleDataLikelihoods.size() + distance(sdls.begin(), sdls.end()));
                allSampleDataLikelihoods.insert(allSampleDataLikelihoods.end(), sdls.begin(), sdls.end());
            }
            // calculate the marginal likelihoods for this population
            marginalGenotypeLikelihoods(genotypeCombos, allSampleDataLikelihoods);
            // store the marginal data likelihoods in the results, for easy parsing
            // like a vector -> map conversion...
            results.update(allSampleDataLikelihoods);
        }

        map<string, int> repeats;
        if (parameters.showReferenceRepeats) {
            repeats = parser->repeatCounts(parser->currentSequencePosition(), parser->currentSequence, 12);
        }

        vector<Allele> alts;
        if (parameters.onlyUseInputAlleles
            || parameters.reportAllHaplotypeAlleles
            || parameters.pooledContinuous) {
            //alts = genotypeAlleles;
            for (vector<Allele>::iterator a = genotypeAlleles.begin(); a != genotypeAlleles.end(); ++a) {
                if (!a->isReference()) {
                    alts.push_back(*a);
                }
            }
        } else {
            // get the unique alternate alleles in this combo, sorted by frequency in the combo
            vector<pair<Allele, int> > alternates = alternateAlleles(bestCombo, referenceBase);
            for (vector<pair<Allele, int> >::iterator a = alternates.begin(); a != alternates.end(); ++a) {
                Allele& alt = a->first;
                if (!alt.isNull() && !alt.isReference())
                    alts.push_back(alt);
            }
            // if there are no alternate alleles in the best combo, use the genotype alleles
            // XXX ...
            if (alts.empty()) {
                for (vector<Allele>::iterator a = genotypeAlleles.begin(); a != genotypeAlleles.end(); ++a) {
                    if (!a->isReference()) {
                        alts.push_back(*a);
                    }
                }
            }
        }

        //if (alts.empty()) alts = genotypeAlleles;

        if (!alts.empty() && (1 - pHom.ToDouble()) >= parameters.PVL || parameters.PVL == 0) {

            vcf::Variant var(parser->variantCallFile);

            out << results.vcf(
                var,
                pHom,
                bestComboOddsRatio,
                samples,
                referenceBase,
                alts,
                repeats,
                genotypingTotalIterations,
                parser->sampleList,
                coverage,
                bestCombo,
                alleleGroups,
                partialObservationGroups,
                partialObservationSupport,
                genotypesByPloidy,
                parser->sequencingTechnologies,
                parser)
                << endl;

        } else if (!parameters.failedFile.empty()) {
            // get the unique alternate alleles in this combo, sorted by frequency in the combo
            long unsigned int position = parser->currentPosition;
            for (vector<Allele>::iterator ga =  genotypeAlleles.begin(); ga != genotypeAlleles.end(); ++ga) {
                if (ga->type == ALLELE_REFERENCE)
                    continue;
                parser->failedFile
                    << parser->currentSequenceName << "\t"
                    << position << "\t"
                    << position + ga->length << "\t"
                    << *ga << endl;
            }
            // BED format
        }
        DEBUG2("finished position");

    }

    DEBUG("total sites: " << total_sites << endl
          << "processed sites: " << processed_sites << endl
          << "ratio: " << (float) processed_sites / (float) total_sites);

    delete parser;

    return 0;

}
Пример #21
0
inline BigFloat Min<BigFloat>( const BigFloat& alpha )
{
    BigFloat one(1,alpha.Precision());
    return one << (MinExponent<BigFloat>()-1);
}
Пример #22
0
inline BigFloat Max<BigFloat>( const BigFloat& alpha )
{
    BigFloat one(1,alpha.Precision());
    return (one-Epsilon(one)) << MaxExponent<BigFloat>();
}
Пример #23
0
  NxI32 CommandCallback(NxI32 token,NxI32 count,const char **arglist)
  {
  	NxI32 ret = 0;

    saveMenuState();

		switch ( token )
		{
      case MC_MEMORY_REPORT:
        break;

      case MC_FLOATING_POINT_RESOLUTION:
        if ( count == 2 )
        {
          MultiFloatType type = MFT_MEDIUM;
          if ( stricmp(arglist[1],"SMALL") == 0 )
            type = MFT_SMALL;
          else if ( stricmp(arglist[1],"MEDIUM") == 0 )
            type = MFT_MEDIUM;
          else if ( stricmp(arglist[1],"BIGFLOAT") == 0 )
            type = MFT_BIG;
          else if ( stricmp(arglist[1],"FIXED32") == 0 )
            type = MFT_FIXED32;
          tf_setFloatingPointResolution(gTfrac,type);
          gLog->Display("Setting Floating Point Resolution to: %s\r\n", arglist[1] );
        }
        break;
      case MC_SHOW_NORMALS:
        if ( count == 2 )
        {
          setShowNormals( getBool(arglist[1]) );
        }
        break;
      case MC_ENVIRONMENT_TEXTURE:
        if ( count == 2 )
        {
          const char *t = arglist[1];
          if ( gFileSystem ) t = gFileSystem->FileOpenString(t,true);
          gPd3d->setEnvironmentTexture(t);
        }
        break;
      case MC_ROTATION_SPEED:
        if ( count == 2 )
        {
          NxF32 rspeed = (NxF32)atof( arglist[1] );
          setRotationSpeed(rspeed);
        }
        break;
		  case MC_OPTIMIZE_MESH:
				if ( !mStartup )
				{
					tf_state(gTfrac,TS_OPTIMIZE_MESH);
				}
				break;
      case MC_FILTER_FRACTAL:
        if ( !mStartup )
        {
          tf_state(gTfrac,TS_FILTER_FRACTAL);
        }
        break;
      case MC_DEFAULT_MANDELBROT:
				if ( !mStartup )
				{
          BigFloat xleft;
          BigFloat xright;
          BigFloat ytop;
          xleft.FromDouble(-2.5);
          xright.FromDouble(0.75);
          ytop.FromDouble(-1.5);
          tf_setFractalCoordinates(gTfrac,xleft,xright,ytop);
          tf_action(gTfrac,FA_MOUSE_CENTER,false,1024/2,768/2);
				}
        break;
      case MC_CLAMP_LOW:
        if ( count == 2 && gTfrac )
        {
          NxF32 c = (NxF32) atof( arglist[1] );
          tf_state(gTfrac,TS_CLAMP_LOW,false,0,c);
        }
        break;
      case MC_CLAMP_HIGH:
        if ( count == 2 && gTfrac )
        {
          NxF32 c = (NxF32) atof( arglist[1] );
          tf_state(gTfrac,TS_CLAMP_HIGH,false,0,c);
        }
        break;
      case MC_CLAMP_SCALE:
        if ( count == 2 && gTfrac )
        {
          NxF32 c = (NxF32) atof( arglist[1] );
          tf_state(gTfrac,TS_CLAMP_SCALE,false,0,c);
        }
        break;
      case MC_WIREFRAME_OVERLAY:
        if ( count == 2 && gTfrac )
        {
          bool state = getBool(arglist[1]);
          tf_state(gTfrac,TS_WIREFAME_OVERLAY,state);
        }
        break;
      case MC_VIEW3D:
        if ( count == 2 )
        {
					gView3d = getBool(arglist[1]);
          if ( gView3d )
          {
            NxF32 eye[3];
            NxF32 look[3];
            look[0] = 0;
            look[1] = 0;
            look[2] = 0;
            eye[0] = 200;
            eye[1] = 250;
            eye[2] = 200;
            lookAt(eye,look);
          }
        }
        break;
      case MC_FRACTAL_COORDINATES:
        if ( count == 4 && gTfrac )
        {
          BigFloat xleft =  arglist[1];
          BigFloat xright = arglist[2];
          BigFloat ytop   = arglist[3];
          tf_setFractalCoordinates(gTfrac,xleft,xright,ytop);
        }
        break;
      case MC_COLOR_PALETTE:
        if ( count == 2 && gTfrac )
        {
          tf_setPal(gTfrac,arglist[1]);
        }
        break;
		  case MC_ITERATION_COUNT:
				if ( count == 2 && gTfrac )
				{
					NxU32 icount = (NxU32)atoi(arglist[1]);
					tf_state(gTfrac,TS_ITERATION_COUNT,false,icount);
				}
				break;
		  case MC_CLOCK_CYCLES:
				if ( count == 2 && gTfrac )
				{
					NxU32 icount = (NxU32)atoi(arglist[1]);
					tf_state(gTfrac,TS_CLOCK_CYCLES,false,icount);
				}
				break;
			case MC_USE_THREADING:
				if ( count == 2 && gTfrac )
				{
					bool state = getBool(arglist[1]);
  			  tf_state(gTfrac,TS_THREADING,state);
  			}
				break;

			case MC_SMOOTH_COLOR:
				if ( count == 2 && gTfrac )
				{
					NxI32 cscale  = atoi(arglist[1]);
					tf_state(gTfrac,TS_SMOOTH_COLOR,false,cscale);
				}
				break;

      case MC_PREVIEW_ONLY:
        if ( count == 2 && gTfrac )
        {
          bool state = getBool(arglist[1]);
          tf_state(gTfrac,TS_PREVIEW_ONLY,state);
        }
        break;
			case MC_RECTANGLE_SUBDIVISION:
        if ( count == 2 && gTfrac )
        {
          bool state = getBool(arglist[1]);
          tf_state(gTfrac,TS_RECTANGLE_SUBDIVISION,state);
        }
        break;
			case MC_PSLOOKAT:
				//            0      1      2      3       4      5       6
				// Usage: PsLookAt <eyex> <eyey> <eyez> <lookx> <looky> <lookz>
				if ( count == 7 )
				{
					NxF32 eye[3];
					NxF32 look[3];

					eye[0] = (NxF32) atof( arglist[1] );
					eye[1] = (NxF32) atof( arglist[2] );
					eye[2] = (NxF32) atof( arglist[3] );

					look[0] = (NxF32) atof(arglist[4] );
					look[1] = (NxF32) atof(arglist[5] );
					look[2] = (NxF32) atof(arglist[6] );

					lookAt(eye,look);

				}
				break;
			case MC_PSSCRIPT:
				{
					const char *fname = 0;
					if ( count >= 2 )
					{
						fname = arglist[1];
					}
#if TODO
  				SoftFileInterface *sfi = gSoftBodySystem->getSoftFileInterface();
  				if ( sfi )
  				{
  					fname = sfi->getLoadFileName(".psc", "Select a demo script to run.");
  				}
  				if ( fname )
  				{
  					CPARSER.Parse("Run \"%s\"",fname);
  				}
#endif
				}
				break;
		}


    return ret;
  }
Пример #24
0
vector<double> GaussElimination::solveLinearEquationByBigFloat(vector<vector<double>> matrix, vector<double> v)
{
	row = matrix.size();
	col = matrix[0].size();

	if( row != col )
	{
		cout << "It has to be a linear equation (row != col)." << endl;
		return vector<double>(0);
	}

	if( row == 0 )
	{
		cout << "There are no member in equation (row = col = 0)." << endl;
		return vector<double>(0);
	}

	if( row != v.size() )
	{
		cout << "Length of vector matched not matrix size." << endl;
		return vector<double>(0);
	}

	// umwandlung in bigfloats und anhängen des vectors
	vector<vector<BigFloat>> matrixBF(row);
	unsigned int newcol = col + 1;

	for(unsigned int r = 0; r < row; ++r)
	{
		vector<BigFloat> vBF(newcol);
		matrixBF[r] = vBF;
		for(unsigned c = 0; c < newcol; ++c)
		{
			BigFloat bf;
			// letzte spalte kommt vom vector
			if( c == col )
				bf.set_with_double( v[r] );
			else
				bf.set_with_double( matrix[r][c] );

			matrixBF[r][c] = bf;
		}
	}

	//writeMatrix(matrixBF);

	// für alle reihen
	for(unsigned int indexDiagonal = 0; indexDiagonal < row; ++indexDiagonal)
	{
		bool success = handleEliminatingValuesInRowByBigFloat(matrixBF, indexDiagonal);
		if(!success)
		{
			cout << "Current row has problems. Row: " << indexDiagonal << endl;
			return vector<double>(0);
		}
	}

	vector<double> coefficients(row);

	// letzte spalte = coefficients -> return letzte spalte als vector
	for(unsigned int i = 0; i < row; ++i)
		coefficients[i] = matrixBF[i][col].getdouble();

	return coefficients;
}
BigFloat BigFloat::div(const BigFloat &x,size_t p) const{
    //  Division
    return this->mul(x.rcp(p),p);
}
BigFloat BigFloat::div(const BigFloat &x,size_t p,int tds) const{
    //  Division
    return this->mul(x.rcp(p,tds),p,tds);
}