-- Cost to make a review. Used by the evaluator too.
-- I'm using quadratic cost functions as a first attempt.
-assignmentCost = \pref -> (numAsWt 10 + pref) ^ 2,
+assignmentCost = \pref -> (widenInteger 10 + pref) ^ 2,
-- Bonus for a first knowledgeable or expert review.
knowledgeableBonus = 1000,
-- its "unhappiness". Default is [reviewsEachProposal, ..., 1] since it's most
-- important for the best review to be good.
reviewEvalWeights = let rep = reviewsEachProposal pmDefaults in
- map numAsWt [rep, rep-1 .. 1]
+ map widenInteger [rep, rep-1 .. 1]
}
import Formatter
type Wt = Double -- Can be any RealFrac.
-numAsWt x = fromInteger (toInteger x)
+widenInteger x = fromInteger (toInteger x)
data PMInstance = PMInstance
Int -- numReviewers
}
randomTopic cfg = withWeight $
- map (\i -> (numAsWt (i+1) ** topicZipfExponent cfg, return i))
+ map (\i -> (widenInteger (i+1) ** topicZipfExponent cfg, return i))
[0 .. numTopics cfg - 1]
randomProposalInfo cfg = do
let
totalReviews = (reviewsEachProposal cfg) * numProps
totalRelativeLoad = foldl (+) 0 (map (rloadA !) [0 .. numRvrs - 1])
- targetLoad i = ceiling (numAsWt totalReviews * (rloadA ! i) / totalRelativeLoad)
+ targetLoad i = ceiling (widenInteger totalReviews * (rloadA ! i) / totalRelativeLoad)
-- A...H refer to idea book p.429
edgesABC = do
i <- [0 .. numRvrs - 1]
let freeEdgeA = (source, rvrNode i 0, REdge undefined tl 0)
let nonfreeEdgesA = do
l <- [tl .. tl + (loadTolerance cfg) - 1]
- let costA = marginalLoadCost cfg ((numAsWt (l - tl) + 1/2) / numAsWt (loadTolerance cfg))
+ let costA = marginalLoadCost cfg ((widenInteger (l - tl) + 1/2) / widenInteger (loadTolerance cfg))
[(source, rvrNode i 0, REdge undefined 1 costA)]
let edgesBC = do
l <- [0 .. tl + (loadTolerance cfg) - 1]
- let costB = marginalBoringCost cfg ((numAsWt l + 1/2) / numAsWt tl)
+ let costB = marginalBoringCost cfg ((widenInteger l + 1/2) / widenInteger tl)
let edgeB = (rvrNode i 0, rvrNode i 1, REdge undefined 1 costB)
- let costC = marginalVeryBoringCost cfg ((numAsWt l + 1/2) / numAsWt tl)
+ let costC = marginalVeryBoringCost cfg ((widenInteger l + 1/2) / widenInteger tl)
let edgeC = (rvrNode i 1, rvrNode i 2, REdge undefined 1 costC)
[edgeB, edgeC]
[freeEdgeA] ++ nonfreeEdgesA ++ edgesBC