/*
 * FuzzyRule.java
 *
 * Created on July 5, 2002, 7:11 PM
 */

package uk.ac.leeds.ccg.projects.MedAction.FuzzyInference;

/**
 * FuzzyRule is corresponding to fuzzy rule in Fuzzy Logic definition
 * 
 * @author jianhui jin
 */
public class FuzzyRule implements java.io.Serializable{
    
    // variable name in this rule
    private String[] variableName = {"","","","",""};
    
    // fuzzy set name in this rule corresponding to the variable names' position above
    private String[] memberName = {"","","",""};
    
    // fuzzification result for the fuzzy set corresponding to the fuzzy set position above
    private double[] memberDegree = null;
    
    // logic operator name definition
    private String[] operatorName = {"AND","OR","AND NOT","OR NOT"};
    
    // output variable fuzzy set's name
    private String outMember = "";
    
    // output degree
    private double outDegree;
    
    // confidence value in the range of 1 - 10
    // the confidence of this rule, the result will time this value show it is 
    // more important than others
    private int confidence = 1;
    
    
    /** Creates a new instance of FuzzyRule */
    public FuzzyRule() {
        
    }
    
    /**
     *
     * @param vName varaible name
     * @param mName fuzzy set name corresponding to variable name above
     * @param opName operator name corresponding to member name above
     * @param outM output fuzzy set name
     * @param confidence confidence of this rule, 1 <= confidence <= 10
     */    
    public FuzzyRule(String[] vName, String[] mName, String[] opName,String outM,int confidence) {
        
        this.setVariableName(vName);
        this.setMemberName(mName);
        this.setOutMember(outM);
        this.setOperatorName(opName);
        this.setConfidence(confidence);
    }
    
    
    // a set of input will result in a set of fuzzification
    // a rule may take of them, may only some of them into logic operation
    // since a fuzzificationResult object will contain all degrees for all members in a variable 
    // for only one input value x.
    private void setDegree( FuzzificationResult[] f ) {
        Double[] temp = new Double[ variableName.length ];
        String[] tempMember = null;
        Double[] tempDegree = null;
        
        
        for ( int i = 0; i < temp.length; i ++ ) {
            // from a variable, take out all fuzzy set name, and degrees
            for ( int j = 0; j < f.length; j ++ ) {
                if ( f[j].getVariableName().equalsIgnoreCase( this.variableName[i] ) ) {
                    tempMember = f[j].getMemberName(); 
                    tempDegree = f[j].getMemberDegree(); 
                    break;
                }
                
            }
            // get the fuzzy set name and degree required for index i, 
            for ( int m = 0; m < tempMember.length; m ++ ) {
                if( tempMember[m].equalsIgnoreCase( this.memberName[i] ) ) {
                   temp[i] = tempDegree[m];
                }
            }
      
        }
        // get double value
        memberDegree = new double[ temp.length ];
        for ( int i = 0; i < temp.length; i ++ ) {
            memberDegree[ i ] = temp[ i ].doubleValue();}
        
    }
    
    // do logic operation
    private void doFuzzyOperation(){
       outDegree=memberDegree[0];
        for(int i=0;i<operatorName.length;i++)
       {
           if(operatorName[i].equalsIgnoreCase("AND"))
           {outDegree=doAnd(outDegree,this.memberDegree[i+1]);continue;}
           else if(operatorName[i].equalsIgnoreCase("OR"))
           {outDegree = doOr(outDegree,this.memberDegree[i+1]);continue;}
           else if(operatorName[i].equalsIgnoreCase("AND NOT"))
           {outDegree=doAnd(outDegree,doNot(this.memberDegree[i+1]));continue;}
           else if(operatorName[i].equalsIgnoreCase("OR NOT"))
           {outDegree=doOr(outDegree,doNot(this.memberDegree[i+1]));continue;}
       }
       
    }
    // do logic And operation
    private double doAnd(double a,double b) {
           return a * b;
    }
    // do logic Or operation
    private double doOr(double a, double b){
       return a + b - a * b;
    }
    // do Not operation
    private double doNot(double a){
       return 1.0d - a;
    }
    // it call set degree first to set f,
    // then do fuzzy operation
    // just want to make code tidy
    // so seperate them
    private void doFuzzyInference(FuzzificationResult[] f){
        setDegree( f );
        doFuzzyOperation();
        
    
    }
    
    
    /**
     * call doFuzzyInference(f) only
     * put in the fuzzification result 
     * then get out of logic operation degree from this rule
     * @param f fuzzificationResult for one set of inputs
     * @return
     */    
    public  double getOutMemberDegree(FuzzificationResult[] f){
        
        doFuzzyInference(f);
        
        return outDegree;  
        
        
    }
    
    
    /** index is 0 to operatorName[] length-1
     */
    public void setOperatorName(String opName,int index){
        operatorName[index]=opName;
    }
    
    /** set all Operators
     */
    public void setOperatorName(String[] opName){
       
        operatorName=new String[opName.length];
        for(int i=0;i<operatorName.length;i++)
        {
            operatorName[i]=opName[i];
        }
    }
    
    /** get all Operators
     */
    public String[] getOperatorName(){
        return operatorName;
    }
    
    /** get one Opeartor using index: 0 to length - 1
     */
    public String getOperatorName(int index){
        return operatorName[index];
    }
    
    
    
    /**
     *
     * @return output variable name
     */    
    public String getOutMember(){
        return outMember;
    }
    
    
    /**
     *
     * @param outM output variable name
     */    
    public void setOutMember(String outM){
        outMember=outM;
        
    }
    
    
    /**
     * put a variable name, get the corresponding member name
     * @param vName variable name
     * @return
     */    
    public String getMemberName(String vName){
        String temp="";
        for(int i=0; i< variableName.length; i++)
            if(vName.equals(variableName[i])) {temp = memberName[i];break;}
        return temp;
    }
    
    /**
     * 
     * @return all variable names
     */    
    public String[] getVariableName(){
        return variableName;
    }
    
    /**
     *
     * @return all members name
     */    
    public String[] getMemberName(){
        return memberName;
    }
    
    
    
    
    
    
    
    /**
     *
     * @param vName
     * @param mName
     */    
    public void setMemberName(String vName, String mName){
        for(int i=0; i< variableName.length; i++)
            if(vName.equals(variableName[i])) {memberName[i]=mName;}
    }
    
    /**
     *
     * @param vName
     */    
    public void setVariableName(String[] vName) {
        variableName=new String[vName.length];
        for(int i=0;i<vName.length;i++)
           {variableName[i]=vName[i];}
    }
    
    /**
     *
     * @param mName
     */    
    public void setMemberName(String[] mName) {
        memberName=new String[mName.length];
        for(int i=0;i<mName.length;i++){
        memberName[i]=mName[i];}
    }
    
    /**
     *
     * @param confidence
     */    
    public void setConfidence(int confidence) {
        
        if(confidence > 10) this.confidence = 10;
        else if (confidence < 1) this.confidence = 1;
        else this.confidence = confidence;
    }
    
    /**
     *
     * @return
     */    
    public int getConfidence() {
        return confidence;
    }
    
}