minimum bounding ellipsoid example does not work in 12.1.1.0

I am surprised that WRI never checks previous examples before shipping new versions. The following example is mentioned and highlighted on the webpage. It does not work in 12.1.1.0 and as far as I remember it used to work in older version 12.0 perhaps. Does someone else has trouble running this example with a fresh kernel. I have filed a bug report nevertheless Case number 4696657

https://www.wolfram.com/language/12/convex-optimization/minimal-bounding-ellipsoid.html?product=mathematica

I get this output below:

enter image description here

Example of Dependent Types?

Say you have 3 objects, a global MemoryStore, which has an array of MemorySlabCache objects, and each MemorySlabCache has an array of MemorySlab objects. Sort of like this:

class MemoryStore {   caches: Array<MemorySlabCache> = [] }  class MemorySlabCache {   size: Integer   slabs: Array<MemorySlab> = [] }  class MemorySlab {    } 

But the thing is, this doesn’t capture everything. It also needs to capture the fact that each MemorySlabCache has a size, which is used to tell what size the MemorySlab objects are it contains. So it’s more like this:

class MemoryStore {   caches: Array<MemorySlabCache> = [] }  class MemorySlabCache {   size: Integer   slabs: Array<MemorySlab<size>> = [] }  class MemorySlab<size: Integer> {    } 

Then we create our caches:

let 4bytes = new MemorySlabCache(size: 4) let 8bytes = new MemorySlabCache(size: 8) ... let 32bytes = new MemorySlabCache(size: 32) ... store.caches.push(4bytes, 8bytes, ..., 32bytes, ...) 

Does this count as a "dependent type", "a type whose definition depends on a value"? Since the type of the Array<MemorySlab<size>> is dependent on the value assigned to the size field on MemorySlabCache. If not, what is this? What would make it into an example of dependent types?

What is the earliest example of a varint monster in a published adventure?

In an answer to another question I made the point that using non-standard variants of published monsters has been common practice since the early days of RPGs. This was based on my own experience, but I am certain I have seen the practice in published aventures. What is the earliest instance of a variant monster in a published adventure?

How I am defining the term "variant monster":

  • A variant monster must be based on a published, official monster but differs from the official monster in a significant way. By significant way, I mean any change in physical statisics (including hit points outside the range normally possible) or a change in the monster’s physical description that might cause players to misidentify it or not notice it (example: red slime with green slime stats).
  • Includes any monster with abilities not accounted for in its official description, such as a spell-casting medusa or a psionic basilisk.
  • Includes any monster that behaves in a way that would normally be impossible for that monster (example: a sentient iron golem that acts on its own free will). But this does not include a creature that has been turned into a monster and still behaves as its natural self (example: a gnome trapped inside an iron golem’s body).
  • Does not include new monsters that are not based on existing oficial monsters.
  • Does not include new types of old monsters that receive a full description in the module and possibly later were published as monsters in supplements. Example: the drow (mentioned briefly, not statted in the 1e Monster Manual) was fully described and statted in the appendix of the first adventure in which they appeared (G3 Hall of the Fire Giant King) and was later published in the 1e Fiend Folio, so drow is not a variant monster.
  • Does not include monsters that are physically and statistically the same as their official type but behave in an unusual way (e.g., a good-aligned red dragon or a cunning, educated ogre).
  • Does not include monsters equipped in an unusual way.

Using an example to comprehend why “safely” erasing a drive yields better results than filling it up with meaningless data

A hypothetical 1GB USB stick is full of sensitive documents/images/etc. and it is not encrypted.

The owner wishes to discard it and is aware of having to safely erase it first.

There are several tools and utilities to do this. Some can be configured to do it “faster yet less safely”, others do it “slower but more safely”.

As opposed to have it erased using all the different ways known to do this, the owner chooses to simply drag all the current items to the recycle bin and then paste one 1GB (~2-hour) black screen movie file to the USB stick.

Again, no fancy erase utilities are used. The USB stick is then discarded.

If it falls into the wrong hands, can any of the sensitive files (that filled the stick before the movie file was pasted) be retrieved?

(1) If no, why do complex hard drive erase utilities exist? Some of them feature “safe” erase procedures that take houuurs, when simply filling a soon to be discarded HD with meaningless files, can do the job?

(2) If yes, how can 2GB (movie file + sensitive files) co-exist in a 1GB stick? Seems to me like the only logical explanation is (a) the movie file was in fact less than 1GB, (b) the USB stick was secretly larger than 1GB as stated, or (c) the movie file was copy-pasted only partially and the owner did not notice.

Potential Example of an algorithm failure

I was looking an algorithm to solve a problem of finding whether and array contains a quadruple with sum = k,(k is input) mentioned at GeeksforGeeks. In one solution the approach mentioned is below,which i think i not correct:

  1. Store all possible two elements pairs of array in some another auxiliary array and also store i,j indices of the elements.There will be $ C(n,2)$ pairs.
  2. Sort the auxiliary array.
  3. Take two pointers,left=0 and right=n-1 to auxiliary array.

3.1. If auxiliary[left]+auxiliary[right]==k and there is no common index in elements represented by left and right, we return true.

3.2 else If auxiliary[left]+auxiliary[right]<k, we do left++

3.3 else we do right– 3.4 And this goes in continues loop until left<right or we get element at 3.1

Now my doubt is that in case sum of left and right elements=k and there is some common element between left and right,then this algo will do right–. I want to understand that why we do right– here and no left++ and the other way.I think there must be some example where this scenario will make algorithm fail but i am not able to produce that.Can some tell that whether it will indeed fail or prove that it is always correct?

What is a make sense (meaningful) example of language that an unrestricted grammar could generate?

I have learned that:

  1. Unrestricted grammar is used to define (or describe) a formal language.
  2. Unrestricted grammar is used to define recursively enumerable set [https://en.wikipedia.org/wiki/Recursively_enumerable_set][1].

I’d like to find a meaningful example for #1 case which is similar to below context sensitives grammar example to learn the purpose of unrestricted grammar. I could find a meaningful example for context sensitives grammar but I could not find a one for the unrestricted grammar yet. Could you help me?

Language for “Network racing game record” with below record instances:

Mr. Bean Male Player 1

Ms. Emma Female Player 2

Mr. Hải n/a Computer 3

Ms. Tú n/a Computer 4

Production rule:

S ⟶ Title Name TAB Sex UserType TAB Rank

Title WomanName ⟶ "Ms. " WomanName

Title ManName ⟶ "Mr. " ManName

WomanName TAB Sex "Player" ⟶ WomanName TAB "Female" "Player"

ManName TAB Sex "Player" ⟶ ManName TAB "Male" "Player"

Name TAB Sex "Computer" ⟶ Name TAB "n/a" "Computer"

Name ⟶ WomanName

Name ⟶ ManName

Sex ⟶ "Male"

Sex ⟶ "Female"

UserType ⟶ "Player"

UserType ⟶ "Computer"

Rank ⟶ "1"

Rank ⟶ "2"

Rank ⟶ "3"

Rank ⟶ "4"

WomanName ⟶ "Emma"

WomanName ⟶ "Tú"

ManName ⟶ "Bean"

ManName ⟶ "Hải"

TAB ⟶ "\t"