Moneymore, Drogheda

Moneymore is a housing estate in Drogheda, County Louth, Ireland. It is located on the northside of the town. It comprises both bungalow and two storey homes. Built in the 1980s by Drogheda Corporation (now Drogheda Borough Council), the housing estate contains 244 houses, a Boxing Club, Moneymore Football Club, Moneymore Community Creche and Connect Family Resource Centre.

In March 2009, the estate was rocked by news of a raging house fire at number 171 Moneymore, in which the residents of the house, the McDonagh family, lost three family members. It is the biggest disaster to hit the estate in its almost 30-year history.

Moneymore Playing Fields are on council owned land zoned for recreational purposes in the 1980s in accordance with the building of Moneymore Estate at the same time. The Playing Fields were in full use by Moneymore Football Club, which was run by the residents of Moneymore throughout the 80’s. However Moneymore Football Club dissolved in the mid 90s and was only reformed in 2003 whereby the Playing Fields were by then a derelict meadow with burnt out cars.

Moneymore Playing Fields now consists of 1 x 11 - a side pitch (standard size) and 2 x 7 - a side pitches (standard size) with a boundary fence and gate to gain entry that was only erected in 2006 through a Peace 11 grant that was awarded to Moneymore FC due to its ongoing work in peace and reconciliation through sport with many clubs from Northern Ireland including Linfield FC, Northland Raiders FC and Lisburn Predators FC.

The outer area from Moneymore Playing Fields has been with continuous housing development over a 15-year period. There are 7 housing estates in the immediate vicinity of Moneymore Playing Fields - 3 being council housing estates, 2 being affordable housing association estates and 1 private housing estate. In general the North side of Drogheda has very little affordable sports and recreational facilities in comparison to the South side of Drogheda however the area of the Twenties has noticeable lack of planning for sport and recreational infrastructure.

Moneymore FC grew with accreditation but on their relationship with Girls Football their developing Girls U-14 team being on the losing end of the 2006 Drogheda and District League Cup Final were crowned League DDSL champions in 2006 and then went on to win the U-14's Dublin Women's Soccer League during that Summer. The girls pushed harder and won the U-14 Drogheda and District League and Cup Final in 2007 and went out in 2008 to win the Girls U-16 North Dublin Brenfer League and Cup Double.

Public transport

Moneymore is served by Bus Éireann route 173, the Northside Drogheda Town Service. There is a bus every hour daytime Mondays to Saturdays inclusive.[1]

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.
gollark: > `globals()[Row + Row] = random.randint(*sys.version_info[:2])`Never actually got used anywhere.> `ε = sys.float_info.epsilon`Also not used. I just like epsilons.> `def __exit__(self, _, _________, _______):`This is also empty, because cleaning up the `_` global would be silly. It'll be overwritten anyway. This does serve a purpose, however, and not just in making it usable as a context manager. This actually swallows all errors, which is used in some places.> `def __pow__(self, m2):`As ever, this is not actual exponentiation. `for i, (ι, 𐌉) in enumerate(zip(self.bigData, m2.bigData)): e.bigData[i] = ι + 𐌉` is in fact just plain and simple addition of two matrices.> `def subtract(forth, 𝕒, polynomial, c, vector_space):`This just merges 4 submatrices back into one matrix.> `with out as out, out, forth:`Apart from capturing the exceptions, this doesn't really do much either. The `_` provided by the context manager is not used.> `_(0j, iｎt(0, 𝕒.n))`Yes, it's used in this line. However, this doesn't actually have any effect whatsoever on the execution of this. So I ignore it. It was merely a distraction.> `with Mаtrix(ℤ(ℤ(4))):`It is used again to swallow exceptions. After this is just some fluff again.> `def strassen(m, x= 3.1415935258989):`This is an interesting part. Despite being called `strassen`, it does not actually implement the Strassen algorithm, which is a somewhat more efficient way to multiply matrices than the naive way used in - as far as I can tell - every entry.> `e = 2 ** (math.ceil(math.log2(m.n)) - 1)`This gets the next power of two in a fairly obvious way. It is used to pad out the matrix to the next power of 2 size.> `with m:`The context manager is used again for nicer lookups.> `Result[0] += [_(0j, iｎt(e, e))]`Weird pythonoquirkiness again. You can append to lists in tuples with `+=`, but it throws an exception as they're sort of immutable.> `typing(lookup[4])(input())`It's entirely possible that this does things.

References
  1. "Archived copy" (PDF). Archived from the original (PDF) on 2015-09-07. Retrieved 2015-08-19.CS1 maint: archived copy as title (link)
This article is issued from Wikipedia. The text is licensed under Creative Commons - Attribution - Sharealike. Additional terms may apply for the media files.