Welcome, guest | Sign In | My Account | Store | Cart
JavaScript, 239 lines
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
// http://bechirot.gov.il/election/about/Pages/CalculatingSeatsMethod.aspx
// http://www.knesset.gov.il/lexicon/eng/seats_eng.htm
// http://main.knesset.gov.il/About/Lexicon/Pages/seats.aspx

/**
 * Computes the Badder-Offer score for specific party.
 *
 * @param {party_votes} Two columns, name-votes pairs.
 * @param {agreement_pairs} Two columns, name-name pairs.
 * @param {party} The name of the party to be shown.
 * @param {qualifying_threshold} אחוז החסימה.
 * @customfunction
 */
function BadderOfferMethod(party_votes, agreement_pairs, party, qualifying_threshold) {
  if (typeof qualifying_threshold === 'undefined')
     qualifying_threshold = 0.0325;
  var parties = prepare_data_(party_votes, agreement_pairs);
  var passed_parties = filter_parties_(parties, qualifying_threshold);
  var agreements_list = get_agreement_list_(passed_parties);
  mandate_splitting_(agreements_list).forEach(split_share_);
  var d = make_dict(parties);
  return d[party].seats;
}

function list_indicator_(x) {
  /* The reason for adding 1 is for determining what the indicator would be
  if the pair would receive that additional seat. */
  return Math.floor(x.votes / (x.seats + 1))
}

/*
 חלוקה ראשונה
 א. מחלקים את סה"כ הקולות הכשרים של הרשימות המשתתפות בחלוקת המנדטים ל-120 (מספר המקומות העומדים לחלוקה), והתוצאה היא המודד הכללי.
 ב. מחלקים את סה"כ הקולות של כל רשימה המשתתפת בחלוקה למודד הכללי ומקבלים את מספר המנדטים שקיבלה הרשימה.
 ג. בדרך זו, מחלקים את הקולות של כל הרשימות שעברו את אחוז החסימה ומשתתפות בחלוקה.
 ד. המספרים השלמים היוצאים מהחלוקה הם מספר המנדטים.
*/
function get_agreement_list_(passed_parties) {
  // first phase
  var total_votes = sum_(passed_parties, 'votes');
  var general_indicator = Math.floor(total_votes / 120);
  passed_parties.forEach(function(p) {
    p.agreement.seats += Math.floor(p.votes / general_indicator);
  });
  return passed_parties.map(key_('agreement')).toSet();
}
/*
חלוקה שניה
ה. מחברים את כל המנדטים, והמנדטים הנותרים עד להשלמת מספר המנדטים ל-120, אותם מחלקים על פי שיטת מודד הרשימה הגדול ביותר.
למשל, בבחירות לכנסת ה-18 נותרו 5 מנדטים לחלוקה.
ו. לצורך חלוקת המנדטים הנותרים, רואים 2 רשימות שהתקשרו ביניהן כרשימה אחת –מחברים את הקולות הכשרים שקיבלו 2 הרשימות ואת מספר המנדטים שקיבלו 2 הרשימות בחלוקה הראשונה, ומתייחסים אליהם בשלב זה כאל רשימת מועמדים אחת, זאת בתנאי שכל אחת מהרשימות עברה את אחוז החסימה.
ז. את המנדטים הנותרים מחלקים לפי מודד לכל רשימה לפי הנוסחה:
 
מודד רשימה     =     מספר הקולות שקיבלה הרשימה
  ________________________________________
לחלק ל     -     מספר המנדטים שקיבלה בחלוקה הראשונה + 1

קובעים כך על פי הנוסחה האמורה את המודד לכל רשימה. רשימה שלה המודד הגדול ביותר מקבלת את המנדט.
ח. לרשימה שקיבלה מנדט בחלוקת המקומות הנותרים נקבע מודד רשימה חדש בהתאם למספר המנדטים שיש לה.
ט. כך קובעים מודדים עד לחלוקת כל המנדטים הנותרים.

*/
function mandate_splitting_(agreements_list) {
  // second phase
  var seats_so_far = sum_(agreements_list, 'seats');
  agreements_list.forEach(function(s) { 
    s.votes = s.parties.sum('votes');
  });
  for (var i = seats_so_far; i < 120; i++) {
    agreements_list.max(list_indicator_).seats += 1;
  }
  return agreements_list
}

/*

3.	חלוקת המנדטים בין הרשימות הקשורות ביניהן
עתה נותר לקבוע איזו רשימה מבין שתי רשימות שהתקשרו ביניהן תקבל את המנדט הנוסף שבו זכו שתיהן בחלוקת המנדטים הנותרים.
קביעה זו נעשית גם היא בשני שלבים.
להלן שלבי החישוב:
שלב א'
א. קביעת מודד פנימי אחיד למנדט של זוג הרשימות המתקשרות.
מודד פנימי אחיד למנדט     =     מספר הקולות הכשרים של שתי הרשימות
  ________________________________________
לחלק ל     -     מספר המנדטים שקיבלו שתי הרשימות
 
ב. בודקים כמה מנדטים אמורה לקבל כל רשימה בנפרד על פי המודד הנ"ל.
היינו,
מספר המנדטים שקיבלה הרשימה בנפרד     =     סה"כ הקולות הכשרים שקיבלה רשימה בנפרד
  ________________________________________
לחלק ל     -                         מודד למנדט

שלב ב'
על פי מספר המנדטים שקיבלו שתי הרשימות ביחד, נותר מנדט נוסף לחלוקה.
את המנדט הנוסף תקבל רשימה שלה "מודד רשימה אישי הגדול ביותר".
חישוב המודד האישי לכל רשימה בנפרד נעשה באותה דרך חישוב של חלוקת המנדטים הנותרים.
היינו, לפי הנוסחה:
מודד רשימה     =     מספר הקולות הכשרים שקיבלה הרשימה בנפרד
  ________________________________________
לחלק ל     -     מספר המנדטים שקיבלה הרשימה בנפרד + 1
 
*/
function split_share_(s) {
  if (s.parties.length === 1) {
    s.parties[0].seats = s.seats;
    return;
  }
  // split between sharing parties
  var indicator = Math.floor(s.votes / s.seats);
  s.parties.forEach(function(p)  {
    p.seats = Math.floor(p.votes / indicator);
  });
  s.parties.max(list_indicator_).seats += 1;
}

/*
1. קביעת הרשימות המשתתפות בחלוקת המנדטים
 א. מסכמים את סך הקולות הכשרים שקיבלה כל אחת מרשימות המועמדים.
 ב. קובעים את מס' הקולות המהווה את אחוז החסימה.
אחוז החסימה = 3.25% מכלל הקולות הכשרים.
 ג. רשימות המועמדים שלא זכו במספר הקולות הדרוש – לא משתתפות בחלוקת המנדטים.
 ד. קובעים את מספר הקולות הכשרים של הרשימות המשתתפות בחלוקת המנדטים.
המספר הכולל של הקולות הכשרים של כל הרשימות פחות מספר הקולות הכשרים של רשימות שלא עברו את אחוז החסימה ולא משתתפות בחלוקה שווה לסה"כ הקולות הכשרים של הרשימות המשתתפות בחלוקת המנדטים.
*/
function filter_parties_(parties, qualifying_threshold_percentage) {
  var total_votes = parties.sum('votes');
  function passed(party) {
    return party.votes >= total_votes * qualifying_threshold_percentage;
  }
  var passed_parties = parties.filter(passed);
  passed_parties.forEach(function(p) {
    p.agreement.parties = p.agreement.parties.filter(passed);
  });
  return passed_parties;
}

function Agreement(parties) {
  return {
    seats: 0,
    parties: parties
  }
}

function Party(name, votes) {
  var res = {
    name: name,
    votes: votes,
    seats: 0
  };
  res.agreement = Agreement([res]);
  return res;
}

function prepare_data_(party_votes, agreement_pairs) {
  var parties = {}
  var all_parties = [];
  party_votes.forEach(function(nv) {
    var name = nv[0], votes = nv[1];
    parties[name] = Party(name, votes);
    all_parties.push(parties[name]);
  });
  agreement_pairs.forEach(function(pair) {
    var p1 = parties[pair[0]];
    var p2 = parties[pair[1]];
    p1.agreement = Agreement([p2, p1]);
    p2.agreement = p1.agreement;
  });
  return all_parties;
}




function make_dict(parties) {
  var res = {};
  parties.forEach(function(p) {
    res[p.name] = p;
  });
  return res;
}

function test() {
  var party_votes = [ 
  ['Likud',	925279],
  ['Labor',	455183],
  ['Shinui',	386535],
  ['Shas',	258879],
  ['Ichud Leumi-Yisrael Beiteinu',	173973],
  ['Meretz',	164122],
  ['United Torah Judaism',	135087],
  ['National Religious Party',	132370],
  ['Hadash',	93819],
  ['Am Ehad',	86808],
  ['Balad',	71299],
  ['Yisrael BeAliyah',	67719],
  ['United Arab List',	65551],
  ];
  var agreement_pairs = [  ];
  var res = BadderOfferMethod(party_votes, agreement_pairs, 'Likud');
  return 0;
}

//HELPERS

function key_(f) {
  if (typeof f == 'string')
     return function(p) { return p[f]; };
  if (typeof f == 'undefined')
    return function(x) { return x; };
  return f;
}

Array.prototype.max = function(key) {
  key = key_(key);
  return this.reduce(function(x, y) {
    return key(x) > key(y) ? x : y;
  });
};
Array.prototype.sum = function(key) {
  return sum_(this, key);
};
Array.prototype.toSet = function(key) {
  var res = [];
  this.forEach(function(p) {
      var val = key_(key)(p);
      if (res.indexOf(val) < 0)
          res.push(val);
  });
  return res;
}
Array.prototype.min = function() {
  return Math.min.apply(null, this);
};

function sum_(arr, key) {
  if (!arr.length)
    return 0;
  return arr.map(key_(key)).reduce(function(a, b) { return a + b });
}
Created by elazar on Wed, 14 Jan 2015 (MIT)
JavaScript recipes (69)
elazar's recipes (5)

Required Modules

  • (none specified)

Other Information and Tasks