Konárovice

Konárovice is a municipality (obec) in the Kolín District of the Czech Republic.

Konárovice
Municipality
The village of Jelen, part of Konárovice
Flag
Coat of arms
Konárovice
Location in the Czech Republic
Coordinates: 50°2′30″N 15°16′30″E
CountryCzech Republic
RegionCentral Bohemian
DistrictKolín
Area
 • Total10.89 km2 (4.20 sq mi)
Elevation
225 m (738 ft)
Population
 (2011)
 • Total767
 • Density70/km2 (180/sq mi)
Time zoneUTC+1 (CET)
 • Summer (DST)UTC+2 (CEST)
Postal code
281 25
Websitewww.konarovice.cz

History

The first mention of Konárovice is from the time of the reign of Boleslaus II. of 976 – 999, who gave the surroundings of Kolín to his youngest son Oldřich. Prince Oldřich built a castle where the village of Přehráď now stands, and called it Oldřiš.

Konárovice was previously called Koňařovice. It is thought that in the 10th century there was a horseman living here, who belonged to the princely officials close to the castle and who bred the horses for the prince on the large meadows of Labe. The prince was not only a militant and power-greedy man, but also a great lover of hunting. He settled more servants in the vicinity – they kept sheep in Ovčáry, cattle in Bychory, hound dogs in Ohaře and birds of prey in Jestřábí Lhota, Kánín and Sokoleč.

The first written mention of the village is from the year 1352 in the registration of the Pope's tithes. In that time Konárovice had already been established as a knight's stronghold. The town's church was mentioned for the first time in 1358.

In the following centuries the owners of Konárovice often changed. In 1772 a farm was bought at auction by the Countess Elizabeth de Quasco. She used it as a summer residence and in 1775 rebuilt the chateau into its present form. Later in the year she ordered the building of a new parish house, but records of the first parish priest date only from 1820. Under control of the Countess, education flourished; in 1810 the 1st ordinary school was opened in Konárovice.

During this same period mulberry gardens were planted in Konárovice for the purpose of silk manufacturing. This trade became very successful, reaching its greatest flowering around 1820.

In 1856 Jan Nepomuk, Count of Harrach, engraving master and chamberlain, gained Konárovice and brought the local economy to its greatest prosperity. He then sold the entire estate to Josef Götzl, manufacturer and magistrate of Karlin. His family was often visited by violinist Jan Kocian, who held a small concert there.

Konárovice state bordered Bychory state, where the famous Czech violinist Jan Kubelík owned a castle.

The village includes a settlement, Jelen, where a brewery and a large restaurant were built in the 14th century. It also has a recreational settlement, Včelín, which has its own interesting history. Its name was derived from the beekeeping and the museum which was opened in 1928.

Winery

On the sunny slopes of Konárovice grapes have been cultivated since time immemorial. On one hill in Konárovice – Na Vinici - the last vineyard of the region was preserved until the beginning of the 20th century. Since 1995, the vineyards gradually have been renewed.

The soil is mainly clay, with loess and diluvian metal. Both land and location are suitable for cultivation of grapes, peaches and apricots.

The average annual temperature is 9.3 °C; the sum of annual precipitation is around 650 mm.

The climate is very similar to that of Southern Moravian (e.g. Velkopavlovická, 9.33 °C), suitable for the production of good wine. The most common current wine plantings are Moravian Muscat, Rhine Riesling, Pinot blanc and Aurelius.

Sightseeing

Near Konárovice there is a village called Žehušice, with the last white deer preserve in the world, and an Empire-era chateau called Kačina.

In the village of Konárovice there are several protected objects:

  • the village chapel Na Labuti
  • St. Jan Nepomuk statue
  • the Virgin Mary statue
  • the former hospital

A chateau (owned by American actor Crispin Glover[1]) and a church can also be found in Konárovice.

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.
gollark: > `def __eq__(self, xy): return self.bigData[math.floor(xy.real * self.n + xy.imag)]`This actually gets indices into the matrix. I named it badly for accursedness. It uses complex number coordinates.> `def __matmul__(self, ǫ):`*This* function gets a 2D "slice" of the matrix between the specified coordinates. > `for (fοr, k), (b, р), (whіle, namedtuple) in itertools.product(I(*iｎt.ℝ(start, end)), enumerate(range(ℤ(start.imag), math.floor(end.imag))), (ǫ, ǫ)):`This is really just bizarre obfuscation for the basic "go through every X/Y in the slice" thing.> `out[b * 1j + fοr] = 0`In case the matrix is too big, just pad it with zeros.> `except ZeroDivisionError:`In case of zero divisions, which cannot actually *happen*, we replace 0 with 1 except this doesn't actually work.> `import hashlib`As ever, we need hashlib.> `memmove(id(0), id(1), 27)`It *particularly* doesn't work because we never imported this name.> `def __setitem__(octonion, self, v):`This sets either slices or single items of the matrix. I would have made it use a cool™️ operator, but this has three parameters, unlike the other ones. It's possible that I could have created a temporary "thing setting handle" or something like that and used two operators, but I didn't.> `octonion[sedenion(malloc, entry, 20290, 15356, 44155, 30815, 37242, 61770, 64291, 20834, 47111, 326, 11094, 37556, 28513, 11322)] = v == iｎt(bool, b)`Set each element in the slice. The sharp-eyed may wonder where `sedenion` comes from.> `"""`> `for testing`> `def __repr__(m):`This was genuinely for testing, although the implementation here was more advanced.> `def __enter__(The_Matrix: 2):`This allows use of `Matrix` objects as context managers.> `globals()[f"""_"""] = lambda h, Ĥ: The_Matrix@(h,Ĥ)`This puts the matrix slicing thing into a convenient function accessible globally (as long as the context manager is running). This is used a bit below.
gollark: * desired

References
  1. http://www.huffingtonpost.com/2011/02/15/crispin-glover-actor-castle_n_823233.html
This article is issued from Wikipedia. The text is licensed under Creative Commons - Attribution - Sharealike. Additional terms may apply for the media files.