Detroit and Mackinac Railway

The Detroit and Mackinac Railway (reporting marks D&M, DM), informally known as the "Turtle Line", was a railroad in the northeastern part of the Lower Peninsula of the U.S. state of Michigan. The main line ran from Bay City north to Cheboygan; it operated from 1894 to 1992.

Detroit and Mackinac Railway
D&M 25011, now on display at the Great Overland Station in Topeka, Kansas
Overview
Reporting markD&M, DM
LocaleMichigan
Dates of operation1894–1992
SuccessorLake State Railway
Technical
Track gauge4 ft 8 1⁄2 in (1,435 mm) standard gauge

At the end of 1925 it incorporated 375 miles of road and 470 miles of track; that year the Turtle Line reported 81 million ton-miles of revenue freight and 7 million passenger-miles. In 1967 it reported 124 million ton-miles on 224 miles of road.

History

The Detroit, Bay City & Alpena Railroad, was a 3 ft 2 in (965 mm) narrow gauge[1] short line operated from Bay City northward to the Lake Huron port of Alpena. The line was converted to 4 ft 8 1⁄2 in (1,435 mm) standard gauge in 1886[2] and was reorganized into the Detroit and Mackinac (D&M) on December 17, 1894. During the late 1890s and the first decade of the Twentieth Century, the timber resources of northeastern Michigan were fully utilized and the D&M expanded its trackage northward from Alpena to Cheboygan. The Bay City-Cheboygan main line prospered, and a stone passenger depot was constructed in Harrisville.[3]

The main constituent of the freight service offered by the D&M and its predecessor railroads was timber from what was then the vast forests of northeastern Michigan; the D&M built spurs and branch lines to the forested areas.[4] Another branch line served the limestone quarries of Rogers City. In 1922, the railroad also had branch lines to Au Gres, Comins, Curran, Hillman, Lincoln, Prescott, and Rose City.[5]

In the 1940s, D&M had enough revenue to be a Class I railroad and it was one of the first such to eliminate steam locomotives in 1948.

In March 1976, the Detroit & Mackinac acquired a combination of trackage and operating trackage rights from the remains of the bankrupt Penn Central that created an alternate main line from Bay City northward, through Gaylord and Cheboygan, to Mackinaw City. However, adverse economic conditions continued to affect railroad operations in the northeastern United States. The road was sold to the Lake State Railway in 1992, and ended its existence as an independent railroad.

The Detroit & Mackinac called itself the "Turtle Line" and its logo symbol was "Mackinac Mac".[6] The railroad bore the hostile backronym of "Defeated & Maltreated".

Passenger service

The D&M mainline from Bay City to Alpena offered sleeping car and meal services between Detroit and Alpena in the 1930s. Continuing coaches were carried over Michigan Central Railroad tracks from Detroit to Bay City.[7] By the 1940s, meal services had disappeared. By 1949, service was reduced to a morning trip from Bay City to Alpena and a reverse trip in the evening.[8] Sleeping cars and Detroit connections were also gone by the 1950s. Passenger service had been eliminated by 1951.[4]

Named train passenger service in the mid-1930s consisted of:[9]

  • Resorter (#1), sleeping car, Detroit to Alpena; coach, Bay City to Alpena (coach passengers would take a Michigan Central train from Detroit to Bay City)
  • Clipper (#3), coach via Michigan Central, Detroit to Bay City; motor coach train from Bay City to Alpena
  • New Yorker (#4), motor coach train from Alpena to Bay City; coach via Michigan Central, Bay City to Detroit
  • Sunset (#12), sleeping car, Alpena to Detroit; coach, Alpena to Bay City (coach passengers would take a Michigan Central train from Bay City to Detroit)

Legacy

The Lake State Railway continued as of 2012 to use traditional handheld technology (picks, shovels, hammers) to replace railroad ties and make other roadbed repairs on surviving trackage that had previously been part of the Detroit and Mackinac system.

A collection of D&M artifacts, including a 1920s switching engine, are housed at the depot in Lincoln, Michigan. The stone depot in Standish, Michigan is also a museum, with rolling stock. The railroad's GE 44-ton locomotive, #10, has been preserved by the Southern Michigan Railroad Society. 0-6-0 Locomotive #8 (Baldwin Locomotive Works #41228) is preserved and awaiting restoration in storage at The Henry Ford (Greenfield Village) in Dearborn, Michigan.

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.

See also

References
  1. Llanso, Steve. "Detroit, Bay City & Alpena 2-4-0 "Porter" Locomotives of the USA". Sweat House Media. Archived from the original on December 21, 2016. Retrieved December 20, 2016.
  2. Commission, Michigan Railroad (1 January 1896). Annual Report – via Internet Archive. Detroit, Bay City and Alpena Railroad narrow.
  3. "How Harrisville got a Stone Depot". Alpena Argus. September 24, 1902. p. Page 8. Archived from the original on March 24, 2016. Retrieved December 20, 2016 – via Michigan's Internet Railroad History Museum.
  4. "A Midwest Regional Railroad — 1930's - 1940's Detroit and Mackinac Railway". Retrieved December 20, 2016.
  5. "Detroit and Mackinac Railway Time Table". Michigan's Internet Railroad History Museum. Archived from the original on July 29, 2016. Retrieved December 20, 2016.
  6. Detroit and Mackinac Railway photographs. Archived January 13, 2016, at the Wayback Machine
  7. 'Official Guide of the Railways,' August 1936, Detroit and Mackinac section
  8. 'Official Guide of the Railways,' August 1949, Detroit and Mackinac section
  9. 'Official Guide of the Railways,' August 1936, Detroit and Mackinac section

Further reading
  • Wakeman, George L., My Story of the Detroit & Mackinac Railroad Library of Michigan, Lansing, 1940.
This article is issued from Wikipedia. The text is licensed under Creative Commons - Attribution - Sharealike. Additional terms may apply for the media files.