source: src/main/java/bargainingchips/utilityfunctions/UF_PeakedFlatPricePeakedFlatQuantity.java@ 341

package bargainingchips.utilityfunctions;

import bargainingchips.Bundle;
import bargainingchips.BundleBuilder;
import bargainingchips.Chip;
import bargainingchips.ChipIssueValue;
import bargainingchips.ChipIssueValueBuilder;
import bargainingchips.wishlist.WishList;
import bargainingchips.wishlist.WishListBuilder;

/**
 * 
 * In addition to {@link wishList}, this utility function inputs piecewise linear curves as for desired 
 * quantity and price per each {@link Chip}. 
 * To this end, the buyer designates 2 `Double' data points, namely p1 and p2, for the price of each {@link Chip}, 
 * where the utility of offers lower than or equal to p1 and higher than or equal to p2 will be 
 * respectively 1 and 0. That is, it is flattened and peaked for values before p1. For the prices offered 
 * between p1 and p2, it has a downward slope. 
 * Quantity is similar to price but also mirrors for quantities less than the exact quantity per each 
 * {@link Chip} at {@link wishList}, that is flattened and peaked at 1 around the exact quantity. To this end, 
 * it inputs 4 `Integer' data deviation, namely d1, d2, d3, and d4, for the acceptable quantities of each {@link Chip} 
 * around the exact wished quantity q, where the utility of quantities lower than or equal to q-d1 or higher 
 * than or equal to q+d4 will be 0, the utility of quantities higher than or equal to q-d2 or less than or equal to q+d3 
 * will be 1, for the quantities offered between q+d3 and q+d4, it has a downward slope, and for the quantities offered 
 * between q+d1 and q+d2, it has an upward slope.
 *  
 *  
 * 
 * @author Faria Nassiri-Mofakham
 *
 */
public class UF_PeakedFlatPricePeakedFlatQuantity implements UtilityFunction {

        private WishList wishlist;                                                      // the exact wished quantity per each Chip                                      
        // Other parts of the buyer's preferences are assigned with desirability degrees of a variety of prices and quantities per each Chip. 
        private ChipIssueValue<Double[]> qtyDeviation;          // `Indivisible' or `divisible' space; list of 4 data points of type `Double' for discreet or continues values; The deviation around the wished quantity per each {@link Chip} could be asymmetric.
        private ChipIssueValue<Double[]> uQty;                          // list of respected single utility for data points regarding quantity deviations
        private ChipIssueValue<Double[]> breakEvenPrice;        // list of 2 data points of type Double determining the price curve
        private ChipIssueValue<Double[]> uBreakEvenPrice;       // list of respected single utility for data points regarding price deviations
        private ChipIssueValue<Double> lambdaC;                         // importance of each Chip (i.e, color)
        private double lambdaP,lambdaQ;                                         // importance of issues (i.e., price, quantity, etc)


        public UF_PeakedFlatPricePeakedFlatQuantity(WishList w, ChipIssueValue<Double[]> qty, ChipIssueValue<Double[]> uQy, ChipIssueValue<Double[]> bEP, ChipIssueValue<Double[]> uBEP, ChipIssueValue<Double> lc, double lp, double lq)
        {
                wishlist=w;
                qtyDeviation=qty;
                uQty=uQy;
                breakEvenPrice=bEP;
                uBreakEvenPrice=uBEP;
                lambdaC=lc; 
                lambdaP=lp; 
                lambdaQ=lq;
        }

        @Override
        public Double getUtility(Bundle b) 
        {               
                double sumWeightedPrice=0.0;
                double sumWeightedQty=0.0;

                if (b!=null)
                {                       
                        for (Chip c : wishlist)
                        {
                                int desiredQ = wishlist.getQuantity(c);

                                Double[] qtyDev = qtyDeviation.getUnitValue(c); // gives 4 data deviation for quantity
                                if (qtyDev.length > 4) 
                                        throw new IllegalStateException("\n\n[Warning] UF_PeakedFlatPriceAndPeakedFlatQuantity::getUtility(Bundle). Input only 4 quantity data deviation! "+ qtyDev);
                                
                                Double[] uQy = uQty.getUnitValue(c); // gives asymmetric utility for the data points in jumping from flat (sloped) to sloped(flat) lines 
                                if (uQy.length > 4) 
                                        throw new IllegalStateException("\n\n[Warning] UF_PeakedFlatPriceAndPeakedFlatQuantity::getUtility(Bundle). Input only 4 values for utility of quantity data points in jumping from flat (sloped) to sloped(flat) lines! "+ uQy);

                                Double[] desiredP = (Double[]) breakEvenPrice.getUnitValue(c); // gives 4 data points for price
                                if (desiredP.length > 4) 
                                        throw new IllegalStateException("\n\n[Warning] UF_PeakedFlatPriceAndPeakedFlatQuantity::getUtility(Bundle). Input only 4 price data points! "+ desiredP);

                                Double[] uPrices= uBreakEvenPrice.getUnitValue(c); // gives utility for the first and second data points in jumping from flat to sloped line
                                if (uPrices.length > 2) 
                                        throw new IllegalStateException("\n\n[Warning] UF_PeakedFlatPriceAndPeakedFlatQuantity::getUtility(Bundle). Input only 2 values for utility of price data points in jumping from flat to sloped line! "+ uPrices);                              
                                
                                Double importanceC= lambdaC.getUnitValue(c);

                                Integer offeredQ = b.getQuantity(c);
                                if (offeredQ == null)
                                        offeredQ = 0;
                                Double offeredP= b.getUnitPrice(c);

                                sumWeightedPrice += importanceC * uPrice(offeredP, desiredP,uPrices);
                                sumWeightedQty += importanceC * uQuantity(offeredQ, desiredQ, qtyDev, uQy);
                        }
                        double u = lambdaP * sumWeightedPrice + lambdaQ * sumWeightedQty; 
                        return ( (u>1) ? 1 : ( (u<0) ? 0 : u) );
                }
                return 0.0;
        }

        /**
         * @param param: the offered price
         * @param data: the designated price data points
         * @param uData: the utility of the the price data points
         * @return the utility regarding the offered price
         */
        private double uPrice(double param, Double[] data, Double[] uData)
        {
                return ((param <= data[0]) ? 1 : (param >= data[1]) ? 0 : uSlope(param, data[0], data[1], uData[0], uData[1]) );                
        }

        /**
         * @param param: the offered quantity
         * @param data: the designated quantity data points 
         * @param uData: the utility of quantity data points 
         * @return the utility regarding the offered quantity
         */
        private double uQuantity(double param, double q, Double[] data, Double[] uData)
        {
                return ( (param <= q-data[0] || param >= q+data[3]) ? 0 : ( (param > q-data[0] && param <= q-data[1] ) ? uSlope(param, data[0], data[1], uData[0], uData[1]) : ( (param > q+data[2] && param < q+data[3]) ? uSlope(param, data[2], data[3], uData[2], uData[3]) : 1) ) );
        }       

        private double uSlope(double param, double data1, double data2, Double uData1, Double uData2)
        {
                return (param-data1)*(uData1-uData2)/(data1-data2)+uData1;
        }

        /**
         * @return a String list of values assigned to a single variable, e.g. list of quantities or prices of a {@link Chip}
         **/    
        private String writeT(ChipIssueValue<Double[]> t)
        {
                String s = "{";
                Double[] j;
                if (t!=null) 
                {
                        for (Chip c: t)
                        {
                                s += " " + c.toString() + "={";
                                j= t.getUnitValue(c);
                                //System.out.println("j: "+j);
                                for (int k=0; k<j.length; k++)
                                        s += j[k].toString()+((k<j.length-1) ? ", " : "");
                                s += "}";
                        }       
                }
                s += " }";
                return s;
        }
        
        @Override
        public String toString()
        {
                return this.getClass().getSimpleName() + ": WishList " + wishlist + ": QtyDeviations "+ writeT(qtyDeviation)+ ": uQtyDeviations "+ writeT(uQty)+": PriceDataPoints "+ writeT(breakEvenPrice) +": uPriceDataPoints "+ writeT(uBreakEvenPrice) + ": Colors' weights "+ lambdaC + ": Issue Price's weight "+ lambdaP + ": Issue Quantity's weight " + lambdaQ;
        }

        public static void main(String[] args) 
        {
                WishList wishlist = new WishListBuilder().addWish("Green", 4).addWish("Yellow", 6).addWish("Orange", 40).build();
                ChipIssueValue<Double[]> deviations = new ChipIssueValueBuilder<Double[]>().addIssue("Green", new Double[] {100.0, 20.0, 50.0, 500.0}).addIssue("Yellow", new Double[] {50.0, 30.0, 30.0, 50.0}).addIssue("Orange", new Double[] {200.0, 40.0, 60.0, 1000.0}).build();
                ChipIssueValue<Double[]> uDev = new ChipIssueValueBuilder<Double[]>().addIssue("Green", new Double[] {0.25, 0.8, 0.9, 0.1}).addIssue("Yellow", new Double[] {0.3, 0.7, 0.7, 0.3}).addIssue("Orange", new Double[] {0.15, 0.95, 0.85, 0.3}).build();
                
                ChipIssueValue<Double[]> prices = new ChipIssueValueBuilder<Double[]>().addIssue("Green", new Double[] {3.0, 3.5, 4.8, 5.0}).addIssue("Yellow", new Double[] {5.0, 5.2, 6.2, 8.0}).addIssue("Orange", new Double[] {1.0, 1.8, 2.5, 3.0}).build();
                ChipIssueValue<Double[]> uPrices = new ChipIssueValueBuilder<Double[]>().addIssue("Green", new Double[] {0.7, 0.2}).addIssue("Yellow", new Double[] {0.8, 0.1}).addIssue("Orange", new Double[] {0.9, 0.3}).build();
                
                ChipIssueValue<Double> wC = new ChipIssueValueBuilder<Double>().addIssue("Green", 0.5).addIssue("Yellow", 0.3).addIssue("Orange", 0.2).build();
                double wP = 0.6;
                double wQ = 0.4;

                
                UF_PeakedFlatPricePeakedFlatQuantity u = new UF_PeakedFlatPricePeakedFlatQuantity (wishlist, deviations, uDev, prices, uPrices, wC, wP, wQ);
                System.out.println(u);

                Bundle offer = new BundleBuilder()
                                                                .addStack("Green", 2.0, 3)
                                                                .addStack("Yellow", 5.0, 4)
                                                                .addStack("Orange", 1.0, 17)
                                //---                           
//                              .addStack("Green", 3.0, 4)              //should give utility 1.0 in weighted additive
//                              .addStack("Yellow", 5.0, 6)
//                              .addStack("Orange", 1.0, 40)
                                //---                           
//                                                              .addStack("Green", 10.0, 1)             //should give utility 0.0 in weighted additive
//                                                              .addStack("Yellow", 10.0, 1)
//                                                              .addStack("Orange", 10.0, 1)    
                                //---
//                                                              .addStack("Red", 1.0, 6)
//                                                              .addStack("Green", 3.0, 15)
//                                                              .addStack("Purple", 0.10, 10)                           
                                .build();
                System.out.println(u.getUtility(offer));
        }
}