James Andrew (educator)

James Andrew, LL.D. (1774?–13 June 1833), was the principal of the East India Company's Military Seminary at Addiscombe, Surrey from 1809 to 1822.

The Revd Dr James Andrew, 1818, by John Constable (1776-1837) - N05965 - Tate Gallery
Mrs James Andrew, 1818, by John Constable (1776-1837) - N05966 - Tate Gallery

Andrew was from Scotland, and received his education at Aberdeen. He attended Marischal College, gaining an MA in 1792.[1] He established a successful private military academy at Woolwich Common which prepared pupils for the Royal Military Academy, Woolwich. In 1809 the East India Company purchased Addiscombe Place, near Croydon, to be its military seminary, training cadets for its private army in India. Andrew was appointed headmaster and Professor of Mathematics. He was elected a Fellow of the Royal Society in March, 1821.[2]

The terms of his contract allowed him to accrue large profits from the cadets' fees: following criticism, the system was changed at his request in 1821.[3][4] He retired in August 1822 and died at Edinburgh on 13 June 1833.

Andrew was the author of Astronomical and Nautical Tables (1805); Institutes of Grammar and Chronological Tables (1817); Key to Scriptural Chronology (1822); and Hebrew Grammar and Dictionary without Points (1823). The copy of this book in the British Library belonged to the Prince Augustus Frederick, Duke of Sussex, and contains an autograph letter of Andrew.

Family

James Andrew was baptised on 24 December 1774 at St Nicholas, Aberdeen. His parents are recorded as James Andrew and Jean Low.[5] James Andrew and Jean Lowe were married on 2 May 1771 at Inverkeithny, Banff.[6] Jean Low was baptised at Inverkeithny on 9 May 1746. Her parents are recorded as Gavin Low and Margaret Alexander.[7]

He married Jane Falding, of Lewisham, on 21 February 1809 at St Paul's Church, Shadwell, now in the London Borough of Tower Hamlets. His address is given as Woolwich, Kent.[8]

In Astronomical and Nautical Tables James Andrew credits his uncle, Gavin Lowe of Islington, "to whom I am indebted for a complete Table of Formulæ for reducing Time out of one denomination to another...".[9] In his will of 1812, Gavin Lowe, "of the Parish of St Mary, Islington", appointed "my dear nephew Doctor James Andrew of Addiscombe" as his executor. After stating that his books and mathematical and optical instruments are to be sold, Gavin Lowe bequeathed his chronometer to James Andrew.[10] Gavin Lowe, of Paradise Row, Islington, died in 1815, aged 72.[11]

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. Anderson, Peter John (Editor), Fasti Academiae Mariscallanae Aberdonensis, Volume 2, 1898, p101
  2. "Library and Archive Catalogue". Royal Society. Retrieved 4 December 2010.
  3. Stearn 2006.
  4. Bourne, J.M. (1979). "The East India Company's Military Seminary, Addiscombe, 1809–1858". Journal of the Society for Army Historical Research. 57: 206-222 (216-7).
  5. Scotland, Select Births and Baptisms, 1564-1950 (Ancestry Library Edition)
  6. Scotland, Select Marriages, 1561-1910 (Ancestry Library Edition)
  7. Scotland, Select Births and Baptisms, 1564-1950 (Ancestry Library Edition)
  8. London, England, Church of England Marriages and Banns, 1754-1932, (Ancestry Library Edition)
  9. Andrew, James, Astronomical and Nautical Tables, 1805, Preface, p viii
  10. London, England, Wills and Probate, 1507-1858 (Ancestry Library Edition)
  11. London, England, Church of England Deaths and Burials, 1813-2003 (Ancestry Library Edition)

Sources
This article is issued from Wikipedia. The text is licensed under Creative Commons - Attribution - Sharealike. Additional terms may apply for the media files.