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

package bargainingchips.utilityfunctions;

import java.util.Random;
import bargainingchips.Bundle;
import bargainingchips.ChipIssueValue;
import bargainingchips.utilityfunctions.UF_BezierPriceBezierQuantity;
import bargainingchips.utilityfunctions.UF_BezierPriceGaussianQuantity;
import bargainingchips.utilityfunctions.UF_CloseToQuantity;
import bargainingchips.utilityfunctions.UF_IntensifiedLessPriceCloseToQuantity;
import bargainingchips.utilityfunctions.UF_LessPrice;
import bargainingchips.utilityfunctions.UF_LessPriceCloseToQuantity;
import bargainingchips.utilityfunctions.UF_PeakedFlatCurvePriceGaussianQuantity;
import bargainingchips.utilityfunctions.UF_PeakedFlatPricePeakedFlatQuantity;
import bargainingchips.utilityfunctions.UF_PeakedPricePeakedQuantity;
import bargainingchips.wishlist.WishList;

/**
 * 
 * This class works to pick a random utility function and pass the buyer's preferences to. 
 * 
 * Besides the buyer operator, it is useful for the experiments in which it is required 
 * to create several random agents to negotiate on behalf of the buyer. 
 * 
 * The utility functions are UF_CloseToQuantity, UF_LessPrice, UF_LessPriceCloseToQuantity, 
 * UF_IntensifiedLessPriceCloseToQuantity, UF_PeakedPricePeakedQuantity, UF_PeakedFlatPricePeakedFlatQuantity, 
 * UF_PeakedFlatCurvePriceGaussianQuantity, UF_BezierPriceBezierQuantity, and UF_BezierPriceGaussianQuantity.
 * 
 * They receive different number and types of parameters. 
 * 
 * 
 * @author Faria Nassiri-Mofakham
 *
 */
public class UF implements UtilityFunction 
{
        WishList                                        wishlist;                       // example: {Yellow=6, Orange=40, Green=4}
        ChipIssueValue<Double>          breakEvenPrices;        // example: {Yellow=5.0, Orange=1.0, Green=3.0}
        ChipIssueValue<Double[]>        prices1;                        // example: ChipIssueValueBuilder<Double[]>().addIssue("Green", new Double[] {3.0, 4.8}).addIssue("Yellow", new Double[] {5.0, 8.0}).addIssue("Orange", new Double[] {1.0, 2.5}).build();
        ChipIssueValue<Double>          uPrices1;                       // example: ChipIssueValueBuilder<Double>().addIssue("Green", 1.0).addIssue("Yellow", 0.8).addIssue("Orange", 0.75).build();
        ChipIssueValue<Integer>         deviations1;            // example: {Yellow=1, Orange=10, Green=1}
        ChipIssueValue<Double[]>        prices2;                        // example: { Yellow={5.0, 5.2, 6.2, 8.0} Orange={1.0, 1.8, 2.5, 3.0} Green={3.0, 3.5, 4.8, 5.0} }
        ChipIssueValue<Double[]>        uPrices2;                       // example: { Yellow={0.8, 0.1} Orange={0.9, 0.3} Green={0.7, 0.2} }
        ChipIssueValue<Double[]>        deviations2;            // example: { Yellow={50.0, 30.0, 30.0, 50.0} Orange={200.0, 40.0, 60.0, 1000.0} Green={100.0, 20.0, 50.0, 500.0} }
        ChipIssueValue<Double[]>        uDev2;                          // example: { Yellow={0.3, 0.7, 0.7, 0.3} Orange={0.15, 0.95, 0.85, 0.3} Green={0.25, 0.8, 0.9, 0.1} }
        ChipIssueValue<Integer[]>       deviations3;            // example: { Yellow={3, 2, 2, 3} Orange={10, 2, 5, 10} Green={2, 1, 2, 3} }
        ChipIssueValue<Double>          wC;                                     // example: {Yellow=0.3, Orange=0.2, Green=0.5}
        double                                          wP;                                     // example: 0.6;
        double                                          wQ;                                     // example: 0.4;
        boolean                                         pVq;                            // example: true; true, if less price is more important; false, if close to quantity is important. 
        int                                             m;                                      // example: 4; input Bezier points

        UtilityFunction u = null;

        public UF (
                        WishList wish,
                        ChipIssueValue<Double> breakEvenP,
                        ChipIssueValue<Double[]> pr1,
                        ChipIssueValue<Double> uPr1,
                        ChipIssueValue<Integer> dev1,
                        ChipIssueValue<Double[]> pr2,
                        ChipIssueValue<Double[]> uPr2,
                        ChipIssueValue<Double[]> dev2,
                        ChipIssueValue<Double[]> uDv2,
                        ChipIssueValue<Integer[]> dev3,
                        ChipIssueValue<Double> c,
                        double p,
                        double q,
                        boolean pq,
                        int n
                        )
        {
                wishlist                        = wish;
                breakEvenPrices         = breakEvenP;
                prices1                         = pr1;
                uPrices1                        = uPr1;
                deviations1                     = dev1;
                prices2                         = pr2;
                uPrices2                        = uPr2;
                deviations2                     = dev2;
                uDev2                           = uDv2;
                deviations3                     = dev3;
                wC                                      = c;
                wP                                      = p;
                wQ                                      = q;
                pVq                                     = pq;
                m                                       = n;
        }

        @Override
        public Double getUtility(Bundle b) 
        {
                //      boolean priceVSQuantity = ((new Random().nextInt(2)+1 == 1) ? true : false);
                switch(new Random().nextInt(9)+1) 
                {
                case 1: u = new UF_CloseToQuantity(wishlist); break;
                case 2: u = new UF_LessPrice(wishlist, breakEvenPrices); break;
                case 3: u = new UF_LessPriceCloseToQuantity(wishlist, breakEvenPrices); break;
                case 4: u = new UF_IntensifiedLessPriceCloseToQuantity(wishlist, breakEvenPrices, pVq); break;
                case 5: u = new UF_PeakedPricePeakedQuantity(wishlist, breakEvenPrices, deviations1, wC, wP, wQ); break;
                case 6: u = new UF_PeakedFlatPricePeakedFlatQuantity(wishlist, deviations2, uDev2, prices2, uPrices2, wC, wP, wQ); break;
                case 7: u = new UF_PeakedFlatCurvePriceGaussianQuantity<Double>(wishlist, prices1, uPrices1, deviations1, wC, wP, wQ); break;
                case 8: u = new UF_BezierPriceBezierQuantity<Double> (wishlist, m, prices2, deviations3, wC, wP, wQ); break;
                case 9: u = new UF_BezierPriceGaussianQuantity<Double> (wishlist, m, prices2, deviations1, wC, wP, wQ); break;
                }
                return u.getUtility(b);
        }

        @Override
        public String toString()
        {
                return u.toString();
        }

//      public static void main(String[] args) 
//      {
//              System.out.println(u.getClass().getName());
//      }
        
}