fractioninstruction.cpp

嵌入式Qt下的一个计算器源码

/****************************************************************************
**
** Copyright (C) 2000-2006 TROLLTECH ASA. All rights reserved.
**
** This file is part of the Phone Edition of the Qtopia Toolkit.
**
** Licensees holding a valid license agreement from Trolltech or any of its
** authorized distributors may use this file in accordance with
** the License Agreement provided with the Licensed Software.
**
** See http://www.trolltech.com/pricing.html or email [e-mail] for
**   information about Trolltech's Commercial License Agreements.
**
** Contact [e-mail] if any conditions of this licensing are
** not clear to you.
**
**
**
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
****************************************************************************/
#ifdef ENABLE_FRACTION

#include "fractioninstruction.h"

// Data type
void BaseFractionInstruction::eval() {
    FractionData *acc = (FractionData *)systemEngine->getData();
    if (argCount == 1)
	doEval(acc);
    else {
	FractionData *num = (FractionData *)systemEngine->getData();
	doEval(acc,num);
	delete num;
    }
    delete acc;
}
BaseFractionInstruction::BaseFractionInstruction()
    : Instruction() {
	type = retType = "Fraction"; // No tr
    }

// Factory
void iFractionFactory::eval() {
    FractionData *ret = new FractionData();
    ret->clear();
    systemEngine->putData(ret);
}
iFractionFactory::iFractionFactory():Instruction() {
    type = retType = "Fraction"; // No tr
    name = "Factory"; // No tr
};

// Copy
void iFractionCopy::eval() {
    FractionData *src = (FractionData *)systemEngine->getData();
    FractionData *tgt = new FractionData();
    tgt->clear();
    tgt->set(((FractionData *)src)->getNumerator(),
	    ((FractionData *)src)->getDenominator());
    systemEngine->putData(src);
    systemEngine->putData(tgt);
};
iFractionCopy::iFractionCopy():BaseFractionInstruction() {
    name = "Copy"; // No tr
    retType = type = "Fraction"; // No tr
    argCount = 1;
};

// Conversion functions
void iConvertDoubleFraction::eval() {

    FractionData *ret = new FractionData();
    double target,tmp, diff;
    qlonglong upper,lower;
    
    DoubleData *doubleD = (DoubleData *)systemEngine->getData();
    target = doubleD->get();
    QString formattedOutput = doubleD->getFormattedOutput();
    bool ok=false;
    if (formattedOutput.contains('.') == 0) {
	ret->set(formattedOutput.toInt(&ok),1);
    }
    int maxCycles = 0;
    if (!ok) {
	diff = upper = lower = 1;
	tmp = 0;
	while ( (diff > 0.0000001 || diff < -0.0000001) &&  maxCycles < 100000) { // limited precision
            maxCycles++;
	    if (tmp < target)
		upper++;
	    else {
		lower++;
		upper = (qlonglong) target * lower;
	    }
	    tmp =  (double) upper / (double) lower;
            diff = tmp-target;
	}
	ret->set(upper,lower);
    }
    if (ok || maxCycles < 100000) {
        systemEngine->putData(ret);
        delete doubleD;
    } else {
        delete ret;
        systemEngine->putData(doubleD); // put data back on stack for recover
        systemEngine->setError(eOutOfRange, false);
    }
}
iConvertDoubleFraction::iConvertDoubleFraction():Instruction() {
    name = "Convert"; // No tr
    retType = "Fraction"; // No tr
    type = "Double"; // No tr
}

// Mathematical functions
void iAddFractionFraction::doEval (FractionData *f,FractionData *fractionNum) {
    FractionData *result = new FractionData();
    qlonglong nn,nd,fn,fd;
    nn = fractionNum->getNumerator();
    nd = fractionNum->getDenominator();
    fn = f->getNumerator();
    fd = f->getDenominator();
    result->set(nn * fd + nd * fn, nd * fd);
    systemEngine->putData(result);
}
void iSubtractFractionFraction::doEval (FractionData *f,FractionData *fractionNum) {
    FractionData *result = new FractionData();
    qlonglong nn = fractionNum->getNumerator();
    qlonglong nd = fractionNum->getDenominator();
    qlonglong fn = f->getNumerator();
    qlonglong fd = f->getDenominator();
    result->set(nn * fd - nd * fn, nd * fd);
    systemEngine->putData(result);
}
void iMultiplyFractionFraction::doEval (FractionData *f,FractionData *fractionNum) {
    FractionData *result = new FractionData();
    qlonglong nn = fractionNum->getNumerator();
    qlonglong nd = fractionNum->getDenominator();
    qlonglong fn = f->getNumerator();
    qlonglong fd = f->getDenominator();
    result->set(nn * fn, nd * fd);
    systemEngine->putData(result);
}
void iDivideFractionFraction::doEval (FractionData *f,FractionData *fractionNum) {
    FractionData *result = new FractionData();
    qlonglong nn = fractionNum->getNumerator();
    qlonglong nd = fractionNum->getDenominator();
    qlonglong fn = f->getNumerator();
    qlonglong fd = f->getDenominator();
    if (nd*fn == 0) {
        systemEngine->setError(eDivZero);
        return;
    }
    result->set(nn * fd, nd * fn);
    systemEngine->putData(result);
}

void iNegateFractionFraction::doEval (FractionData *f) {
    FractionData *result = new FractionData();
    result->set( -f->getNumerator(), f->getDenominator() );
    result->setEdited(true);
    systemEngine->putData(result);
}

iAddFractionFraction::iAddFractionFraction():BaseFractionInstruction() {
    name = "Add"; // No tr
    precedence = 10;
    displayString = "+";
    argCount = 2;
}
iSubtractFractionFraction::iSubtractFractionFraction():BaseFractionInstruction() {
    name = "Subtract"; // No tr
    precedence = 10;
    displayString = "-";
    argCount = 2;
}
iMultiplyFractionFraction::iMultiplyFractionFraction():BaseFractionInstruction() {
    name = "Multiply"; // No tr
    precedence = 15;
    displayString = "x";
    argCount = 2;
}
iDivideFractionFraction::iDivideFractionFraction():BaseFractionInstruction() {
    name = "Divide"; // No tr
    precedence = 15;
    displayString = "/";
    argCount = 2;
}
iNegateFractionFraction::iNegateFractionFraction():BaseFractionInstruction() {
    name = "Negate"; // No tr
    precedence = 0;
    argCount = 1;
}
#endif //ENABLE_FRACTION