001package es.ucm.fdi.gaia.jcolibri.method.retrieve.NNretrieval.similarity.local.recommenders;
002
003import es.ucm.fdi.gaia.jcolibri.exception.NoApplicableSimilarityFunctionException;
004import es.ucm.fdi.gaia.jcolibri.method.retrieve.NNretrieval.similarity.LocalSimilarityFunction;
005
006/**
007 * This function returns the similarity of two numbers (or enums) following 
008 * the INRECA - Less is Better formulae
009 * 
010 * sim(c.a,q.a)= if(c.a < q.a) then 1 else  jump * (max(a) - c.a) / (max(a) - q.a)
011 * 
012 * jump and max(a) must be defined by the designer.
013 */
014public class InrecaLessIsBetter implements LocalSimilarityFunction {
015
016
017        double maxValue;
018        double jump;
019
020        /**
021         * Constructor. max value is ignored for enum types.
022         */
023        public InrecaLessIsBetter(double maxAttributeValue, double jumpSimilarity) {
024            this.maxValue = maxAttributeValue;
025            this.jump = jumpSimilarity;
026        }
027
028        /**
029         * Applies the similarity function.
030         * 
031         * @param caseObject is a Number
032         * @param queryObject is a Number
033         * @return result of apply the similarity function.
034         */
035        public double compute(Object caseObject, Object queryObject) throws NoApplicableSimilarityFunctionException {
036                if ((caseObject == null) || (queryObject == null))
037                        return 0;
038                if (! ((caseObject instanceof Number)||(caseObject instanceof Enum)))
039                        throw new NoApplicableSimilarityFunctionException(this.getClass(), caseObject.getClass());
040                if (! ((queryObject instanceof Number)||(queryObject instanceof Enum)))
041                        throw new NoApplicableSimilarityFunctionException(this.getClass(), queryObject.getClass());
042
043                double caseValue;
044                double queryValue;
045                double max;
046                if(caseObject instanceof Number)
047                {
048                    Number n1  = (Number) caseObject;
049                    Number n2  = (Number) queryObject;
050                    caseValue  = n1.doubleValue();
051                    queryValue = n2.doubleValue();
052                    max = maxValue;
053                }
054                else
055                {
056                    Enum<?> enum1 = (Enum<?>)caseObject;
057                    Enum<?> enum2 = (Enum<?>)queryObject;
058                    caseValue  = enum1.ordinal();
059                    queryValue = enum2.ordinal();
060                    max = caseObject.getClass().getEnumConstants().length;
061                }
062                
063                if(caseValue <= queryValue)
064                    return 1;
065                if(caseValue>=maxValue)
066                    return 0;
067                
068                else return jump * (max-caseValue) / (max - queryValue);
069                
070        }
071        
072        /** Applicable to any Number subinstance */
073        public boolean isApplicable(Object o1, Object o2)
074        {
075                if((o1==null)&&(o2==null))
076                        return true;
077                else if(o1==null)
078                        return (o2 instanceof Number)||(o2 instanceof Enum);
079                else if(o2==null)
080                        return (o1 instanceof Number)||(o1 instanceof Enum);
081                else
082                        return ((o1 instanceof Number)&&(o2 instanceof Number)) ||
083                                ((o1 instanceof Enum)&&(o2 instanceof Enum));
084        }
085
086}