Edinburgh Eastern (Scottish Parliament constituency)

Edinburgh Eastern is a constituency of the Scottish Parliament (Holyrood). It elects one Member of the Scottish Parliament (MSP) by the plurality (first past the post) method of election. Also, however, it is one of nine constituencies in the Lothian electoral region, which elects seven additional members, in addition to nine constituency MSPs, to produce a form of proportional representation for the region as a whole.

Edinburgh Eastern
burgh constituency
for the Scottish Parliament
Edinburgh Eastern shown within the Lothian electoral region and the region shown within Scotland
Current constituency
Created2011
PartyScottish National Party
MSPAsh Denham
Council areaCity of Edinburgh
Created fromEdinburgh East and Musselburgh,
Edinburgh South

For the 2011 Scottish Parliament election, Edinburgh East and Musselburgh was abolished. The successor constituencies are Edinburgh Eastern, and Midlothian North and Musselburgh.

Electoral region
See also: Lothian (Scottish Parliament electoral region)

The other eight constituencies of the Lothian region are Almond Valley, Edinburgh Central, Edinburgh Northern and Leith, Edinburgh Pentlands, Edinburgh Southern, Edinburgh Western, Linlithgow and Midlothian North and Musselburgh

The region includes all of the City of Edinburgh council area, parts of the East Lothian council area, parts of the Midlothian council area and all of the West Lothian council area.

Constituency boundaries and council area

The City of Edinburgh is represented in the Scottish Parliament by five constituencies: Edinburgh Central, Edinburgh Eastern, Edinburgh Northern and Leith, Edinburgh Pentlands, Edinburgh Southern and Edinburgh Western.

Edinburgh Eastern uses the following electoral wards:

Member of the Scottish Parliament
ElectionMemberParty
2011 Kenny MacAskill Scottish National Party
2016 Ash Denham

Election results

2010s
2016 Scottish Parliament election: Edinburgh Eastern[1]
Party Candidate Votes % ±
SNP Ash Denham 16,760 47.3 -0.1
Labour Kezia Dugdale 11,673 33.0 -7.1
Conservative Nick Cook 5,700 16.1 +7.5
Liberal Democrats Cospatric d'Inverno 1,264 3.6 -0.4
Majority 5,087 14.3 +7.0
Turnout 35,397 56.3 +1.4
SNP hold Swing +3.5
2011 Scottish Parliament election: Edinburgh Eastern[2]
Party Candidate Votes % ±
SNP Kenny MacAskill 14,552 47.4 +12.9
Labour Ewan Aitken 12,319 40.1 +3.8
Conservative Cameron Buchanan 2,630 8.6 -4.4
Liberal Democrats Martin Veart 1,227 4.0 -12.2
Majority 2,233 7.3 N/A
Turnout 30,728 54.9 N/A
SNP win (new seat)

Footnotes
  1. http://www.edinburghnews.scotsman.com/news/politics/edinburgh-s-parliament-election-candidates-named-1-4088458
  2. Statement of Persons Nominated Edinburgh Council

See also
gollark: It allocates memory and doesn't consider it a side effect.
gollark: I didn't do any horrible homoglyph hacks with THAT.
gollark: It uses the function, yes.
gollark: So, I finished that to highly dubious demand. I'd like to know how #11 and such work.
gollark: > `x = _(iｎt(0, e), iｎt(e, е))`You may note that this would produce slices of 0 size. However, one of the `e`s is a homoglyph; it contains `2 * e`.`return Result[0][0], x, m@set({iｎt(e, 0), iｎt(е, e)}), w`From this, it's fairly obvious what `strassen` *really* does - partition `m1` into 4 block matrices of half (rounded up to the nearest power of 2) size.> `E = typing(lookup[2])`I forgot what this is meant to contain. It probably isn't important.> `def exponentiate(m1, m2):`This is the actual multiplication bit.> `if m1.n == 1: return Mаtrix([[m1.bigData[0] * m2.bigData[0]]])`Recursion base case. 1-sized matrices are merely multiplied scalarly.> `aa, ab, ac, ad = strassen(m1)`> `аa, аb, аc, аd = strassen(m2)`More use of homoglyph confusion here. The matrices are quartered.> `m = m1.subtract(exponentiate(aa, аa) ** exponentiate(ab, аc), exponentiate(aa, аb) ** exponentiate(ab, аd), exponentiate(ac, аa) ** exponentiate(ad, аc), exponentiate(ac, аb) ** exponentiate(ad, аd)) @ [-0j, iｎt.abs(m2.n * 3, m1.n)]`This does matrix multiplication in an inefficient *recursive* way; the Strassen algorithm could save one of eight multiplications here, which is more efficient (on big matrices). It also removes the zero padding.> `m = exponentiate(Mаtrix(m1), Mаtrix(m2)) @ (0j * math.sin(math.asin(math.sin(math.asin(math.sin(math.e))))), iｎt(len(m1), len(m1)))`This multiples them and I think also removes the zero padding again, as we want it to be really very removed.> `i += 1`This was added as a counter used to ensure that it was usably performant during development.> `math.factorial = math.sinh`Unfortunately, Python's factorial function has really rather restrictive size limits.> `for row in range(m.n):`This converts back into the 2D array format.> `for performance in sorted(dir(gc)): getattr(gc, performance)()`Do random fun things to the GC.
This article is issued from Wikipedia. The text is licensed under Creative Commons - Attribution - Sharealike. Additional terms may apply for the media files.