www.pudn.com > calculator.rar > doubleinstruction.h

/****************************************************************************
**
** 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 sales@trolltech.com for
**   information about Trolltech's Commercial License Agreements.
**
** Contact info@trolltech.com 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.
**
****************************************************************************/
#ifndef CALC_DOUBLEINSTRUCTION_H
#define CALC_DOUBLEINSTRUCTION_H

#include "instruction.h"
#include "doubledata.h"

// Double instruction base
class BaseDoubleInstruction:public Instruction {
public:
    BaseDoubleInstruction();
    ~BaseDoubleInstruction();

    virtual void eval();
    virtual void doEval(DoubleData *,DoubleData *);
    virtual void doEvalI(DoubleData *);
};

// Factory 
class iDoubleFactory:public Instruction {
public:
    iDoubleFactory();
    ~iDoubleFactory(){};
    void eval();
};

// Copy
class iDoubleCopy:public Instruction {
public:
    iDoubleCopy();
    ~iDoubleCopy(){};
    void eval();
};

#ifdef ENABLE_INTEGER
class iConvertIntDouble:public Instruction {
public:
    iConvertIntDouble();
    ~iConvertIntDouble(){};
    Data *eval(Data *);
};
#endif
#ifdef ENABLE_FRACTION
class iConvertFractionDouble:public Instruction {
public:
    iConvertFractionDouble();
    ~iConvertFractionDouble(){};
    void eval();
};
#endif

// Mathematical functions
class iAddDoubleDouble:public BaseDoubleInstruction {
public:
    iAddDoubleDouble();
    ~iAddDoubleDouble(){};
    void doEval(DoubleData *,DoubleData *);
};

class iSubtractDoubleDouble:public BaseDoubleInstruction {
public:
    iSubtractDoubleDouble();
    ~iSubtractDoubleDouble(){};
    void doEval(DoubleData *,DoubleData *);
};

class iMultiplyDoubleDouble:public BaseDoubleInstruction {
public:
    iMultiplyDoubleDouble();
    ~iMultiplyDoubleDouble(){};
    void doEval(DoubleData *,DoubleData *);
};

class iDivideDoubleDouble:public BaseDoubleInstruction {
public:
    iDivideDoubleDouble();
    ~iDivideDoubleDouble(){};
    void doEval(DoubleData *,DoubleData *);
};

#ifdef ENABLE_SCIENCE
// Normal functions
class iDoublePow:public BaseDoubleInstruction {
public:
    iDoublePow();
    ~iDoublePow(){};
    void doEval(DoubleData *,DoubleData *);
};

class iDoubleXRootY:public BaseDoubleInstruction {
public:
    iDoubleXRootY();
    ~iDoubleXRootY(){};
    void doEval(DoubleData *,DoubleData *);
};

// Immediate
class iDoubleSinRad:public BaseDoubleInstruction {
public:
    iDoubleSinRad();
    ~iDoubleSinRad(){};
    void doEvalI(DoubleData *);
};

class iDoubleSinDeg:public BaseDoubleInstruction {
public:
    iDoubleSinDeg();
    ~iDoubleSinDeg(){};
    void doEvalI(DoubleData *);
};
class iDoubleSinGra:public BaseDoubleInstruction {
public:
    iDoubleSinGra();
    ~iDoubleSinGra(){};
    void doEvalI(DoubleData *);
};

class iDoubleCosRad:public BaseDoubleInstruction {
public:
    iDoubleCosRad();
    ~iDoubleCosRad(){};
    void doEvalI(DoubleData *);
};
class iDoubleCosDeg:public BaseDoubleInstruction {
public:
    iDoubleCosDeg();
    ~iDoubleCosDeg(){};
    void doEvalI(DoubleData *);
};
class iDoubleCosGra:public BaseDoubleInstruction {
public:
    iDoubleCosGra();
    ~iDoubleCosGra(){};
    void doEvalI(DoubleData *);
};

class iDoubleTanRad:public BaseDoubleInstruction {
public:
    iDoubleTanRad();
    ~iDoubleTanRad(){};
    void doEvalI(DoubleData *);
};
class iDoubleTanDeg:public BaseDoubleInstruction {
public:
    iDoubleTanDeg();
    ~iDoubleTanDeg(){};
    void doEvalI(DoubleData *);
};
class iDoubleTanGra:public BaseDoubleInstruction {
public:
    iDoubleTanGra();
    ~iDoubleTanGra(){};
    void doEvalI(DoubleData *);
};

class iDoubleASinRad:public BaseDoubleInstruction {
public:
    iDoubleASinRad();
    ~iDoubleASinRad(){};
    void doEvalI(DoubleData *);
};
class iDoubleASinDeg:public BaseDoubleInstruction {
public:
    iDoubleASinDeg();
    ~iDoubleASinDeg(){};
    void doEvalI(DoubleData *);
};
class iDoubleASinGra:public BaseDoubleInstruction {
public:
    iDoubleASinGra();
    ~iDoubleASinGra(){};
    void doEvalI(DoubleData *);
};

class iDoubleACosRad:public BaseDoubleInstruction {
public:
    iDoubleACosRad();
    ~iDoubleACosRad(){};
    void doEvalI(DoubleData *);
};
class iDoubleACosDeg:public BaseDoubleInstruction {
public:
    iDoubleACosDeg();
    ~iDoubleACosDeg(){};
    void doEvalI(DoubleData *);
};
class iDoubleACosGra:public BaseDoubleInstruction {
public:
    iDoubleACosGra();
    ~iDoubleACosGra(){};
    void doEvalI(DoubleData *);
};

class iDoubleATanRad:public BaseDoubleInstruction {
public:
    iDoubleATanRad();
    ~iDoubleATanRad(){};
    void doEvalI(DoubleData *);
};
class iDoubleATanDeg:public BaseDoubleInstruction {
public:
    iDoubleATanDeg();
    ~iDoubleATanDeg(){};
    void doEvalI(DoubleData *);
};
class iDoubleATanGra:public BaseDoubleInstruction {
public:
    iDoubleATanGra();
    ~iDoubleATanGra(){};
    void doEvalI(DoubleData *);
};

class iDoubleLog:public BaseDoubleInstruction {
public:
    iDoubleLog();
    ~iDoubleLog(){};
    void doEvalI(DoubleData *);
};

class iDoubleLn:public BaseDoubleInstruction {
public:
    iDoubleLn();
    ~iDoubleLn(){};
    void doEvalI(DoubleData *);
};

class iDoubleExp:public BaseDoubleInstruction {
public:
    iDoubleExp();
    ~iDoubleExp(){};
    void doEvalI(DoubleData *);
};

class iDoubleOneOverX:public BaseDoubleInstruction {
public:
    iDoubleOneOverX();
    ~iDoubleOneOverX(){};
    void doEvalI(DoubleData *);
};

class iDoubleFactorial:public BaseDoubleInstruction {
public:
    iDoubleFactorial();
    ~iDoubleFactorial(){};
    void doEvalI(DoubleData *);
};

class iDoubleSquareRoot:public BaseDoubleInstruction {
public:
    iDoubleSquareRoot();
    ~iDoubleSquareRoot(){};
    void doEvalI(DoubleData *);
};

class iDoubleCubeRoot:public BaseDoubleInstruction {
public:
    iDoubleCubeRoot();
    ~iDoubleCubeRoot(){};
    void doEvalI(DoubleData *);
};

class iDoubleSquare:public BaseDoubleInstruction {
public:
    iDoubleSquare();
    ~iDoubleSquare(){};
    void doEvalI(DoubleData *);
};
#endif //ENABLE_SCIENCE

class iDoubleNegate:public BaseDoubleInstruction {
public:
    iDoubleNegate();
    ~iDoubleNegate(){};
    void doEvalI(DoubleData *);
};

#endif