Does a Morkoth’s Spell Reflection work against AOE spells like Fireball?

The Morkoth (Volo’s Guide to Monsters page 177-178) has a reaction called "Spell Reflection."

Spell Reflection. If the morkoth makes a successful saving throw against a spell, or a spell attack misses it, the morkoth can choose another creature (including the spellcaster) it can see within 120 feet of it. The spell targets the chosen creature instead of the Morkoth. If the spell forced a saving throw, the chosen creature makes its own save. If the spell was an attack, the spell is rerolled against the chosen creature.

My question is if this applies to AOE spells. The early wording only specifies it has to be a spell that forces a save or is an attack roll. However, "The spell targets the chosen creature instead of the Morkoth" seems to imply that it requires the spell to target the Morkoth specifically. Fireball isn’t a spell that mentions having any "targets."

Does the Morkoth’s Spell Reflection trait work on Area of Effect spells like Fireball?

Implementing Kramers Kronig Relation in Mathematica for Reflection Spectrum

I’m new to Mathematica and I have to solve this problem but all of my approaches are wrong 🙁 So, please can anyone help me with this equation? Here it is: enter image description here

Here is my data : The data is in ln(sqrt(R)), w And here is my code:

   {R, w} = ToExpression@Import[""]; f = Interpolation[Transpose[{Flatten[w], Flatten[R]}]] theta[w_] :=   theta[w] =    2 w/Pi NIntegrate[ f[a]/(a^2 - w^2), {a, 0, 3.2},       Method -> "PrincipalValue", Exclusions -> {(a^2 - w^2) == 0}] //     Quiet DiscretePlot[theta[w], {w, 0.5, 3.5, .25}, AxesOrigin -> {0, 0},   Joined -> True] 

P.S. I know that this question was discussed before, but all the answers that were given I can’t get to work. Very appreciate for any help

How to effectively represent and generate 2D cellular automaton rules that are invariant under rotation and reflection of the input matrix?

Consider cellular automaton rules for a two-dimensional universe with two states, where a cell’s new state can depend on its previous state and the states of the cells in its Moore neighborhood. Such a rule can be modeled as a function that takes as input a 3 by 3 matrix of bits, and outputs a bit.

Such a rule can be represented easily using a string of 512 bits representing the output for each of the $ 2^{3 \times 3}$ input states. Since this representation is bijective, a rule can also be randomly generated by sampling 512 bits.

However, it is sometimes preferable for reasons of aesthetics and comprehensibility that the output of the rule be the same when the input matrix is rotated or flipped horizontally or vertically. The rule for Conway’s Game of Life is an example of a function satisfying this restriction.

Given a function $ r : 2^9 \to 2$ which does not necessarily obey this restriction, we can obtain a function that does by mapping the input to the lexicographically smallest matrix obtainable by reflecting or rotating it before passing to $ r$ . However, this provides little insight into the questions I am interested in:

  • How many functions obey this restriction?
  • How can they be compactly representing using a bit string?
  • How can they be efficiently randomly generated?

Feedback Sought on Java Reflection Factory Example

I set out to create an example or proof of concept of an idea I had and would be interested in receiving constructive feedback on my idea. I needed a Java factory pattern that allowed the end-user of the application to extend it (think add-ons, plug-ins, user contributed content, etc.). So I created a Java factory that uses reflection. While I am doubtful that I am the first to have done this, I have not found [any] examples of it. In my example, I created an abstract class called Vehicle. I then extended Vehicle a number of times (i.e. car, train, boat, airplane, etc.) and placed the subclasses in a separate package. In my example, my factory has a class scanner (does not currently support JAR files) that registers each subclass. Then the factory can be easily called using some class data (i.e. ID, name, whatever) to create a new instance of the subclass. I have included a link to the repo in GitHub (I hope that makes it easier to browse/review). What are your thoughts? Is this practical? Useful? Are there obvious improvements? Easily adapted to support JAR files?

I do want to note that I am aware of Google Guava and the Reflections Library. I wanted to create an example without dependencies on other libraries.

To see the underlying code, please follow link to GitHub repo.


/*   * Create a new instance of the reflection factory by   * passing the package name to the constructor. The class  * scanner will look in this package for classes. All of the  * classes in this package must share the same superclass -  * Vehicle in this case.  */ VehicleFactory vehicleFactory = new VehicleFactory("org.codehamster.vehicles");  /*   * Call the getVehicle() method with the identifier ("name")  * of the class to create a new instance of.  */ Vehicle vehicleOne = vehicleFactory.getVehicle("boat"); Vehicle vehicleTwo = vehicleFactory.getVehicle("train"); Vehicle vehicleThree = vehicleFactory.getVehicle("truck"); Vehicle vehicleFour = vehicleFactory.getVehicle("airplane"); Vehicle vehicleFive = vehicleFactory.getVehicle("car");  /*   * Call each of the new classes with the println() method  * to invoke the toString() method and verify the output  * is correct.  */ System.out.println(vehicleOne); System.out.println(vehicleTwo); System.out.println(vehicleThree); System.out.println(vehicleFour); System.out.println(vehicleFive); 


Vehicle is a boat Vehicle is a train Vehicle is a truck Vehicle is a airplane Vehicle is a car 

Why not replace reflection by bounded reflection in Muller’s approach?

Bounded Reflection: If $ \phi$ is a formula in the language of set theory [i.e.; $ \small \sf FOL(=,\in)$ ], in which all and only symbols $ “y,x_1,..,x_n”$ occur free, and $ \phi^V$ is the formula obtained by merely bounding all quantifiers in $ \phi$ by $ V$ , then all closures of: $ $ x_1,..,x_n \in V \land \forall y (\phi \to y \in V) \ \to \exists x \in V \forall y \in V(y \in x \leftrightarrow \phi^V) $ $ ; are axioms.

Now if we add this principle to the axioms of Extensionality and Super-transitivity, that is: $ V$ is a transitive class that is closed under subclass relation $ \subset$ ; and Separation [using any formula], and Foundation, both over all classes. Then it appears to me that $ V \models ZF$

My question here is: does this theory prove that $ V$ is inaccessible?

I personally suspect that it does not. My point here is that if my suspicion turns to be true, then this theory would have been the one that most capture Muller’s principles about a foundational theory for mathematics, rather than just extending Ackermann’s class theory with a class separation schema as he did. Since in that case we won’t have $ V$ being a model of $ ZF$ , thus lacking a very desirable thing to have if our class theoretic based category theory is to be sufficient [in Muller’s sense] in capturing set theoretic properties! For example: sets have a model!

Note: $ V$ is a primitive constant, informally standing for the class of all sets, as we are working in the language of Ackermann’s set theory.

reflection essay sample

catch 22 essay topics dysfunctional family essay a small place essay quality essay annual day essay reading skills essay characteristics of a good friend essay 123helpme essays
political parties essay…

reflection essay sample

write a reflection essay

english essay friendship whale rider essay essays on life of pi reader response essay essay writing on teachers essay on medical assistant starting a personal essay if i were invisible essay
indian independence day essay…

write a reflection essay

Upward reflection of rank-into-rank cardinals

Rank-into-rank cardinals have the rather intriguing property that they reflect upwards. I would be interested to know how far the upward reflection goes:

1) Does “There exists a rank-into-rank cardinal (of type I3, say)” imply that “There exists an unbounded class of rank-into-rank cardinals (in V) ?”

2) If 1) is false, then can we say something interesting about the supremum of this upward reflecting sequence ? For instance, maybe the supremum has some large cardinal properties of interest ?

3) Finally, existence of a rank-into-rank implies the existence of pretty much all of the other large cardinals. But can we strengthen this along the lines of “If there exists a rank-into-rank cardinal, then there exists an unbounded class of cardinals with property P (in V)” for interesting some property P? By interesting property P, I mean something like “inaccessible” or “Mahlo” or hopefully even stronger like “measurable”.

Replace method using raw SQL with Expression trees and Reflection

I’m working with a large enterprise SQL Server database with many tables (dozens) that are used mainly as lookups to populate dropdown lists, etc. These tables all follow the convention of having (table)Name as the string value of the item. For example the State table has a StateName column with values like California, Florida, etc.

There is an old method used to load data for a dropdown that uses raw SQL, it looks like this:

    public async Task<IEnumerable<string>> GetLookupOptions(string table)     {         List<string> values = new List<string>();          using (var command = _context.Database.GetDbConnection().CreateCommand())         {             command.CommandText = $  "SELECT {table}Name FROM {table} WHERE IsApproved = 1";              _context.Database.OpenConnection();              using (var result = await command.ExecuteReaderAsync())             {                 do                 {                     while (result.Read())                     {                         values.Add(result.GetString(0));                     }                 } while (result.NextResult());             }         }          return values;     } 

This isn’t testable using InMemoryDatabase and only works against an actual database connection. I have rewritten it using Reflection and Expressions to query the DbContext.DbSet<T> based on the table name provided, like this:

    public IEnumerable<string> GetLookupOptions(string table)     {         // Get the Type for State and then replace its name with whatever entity this is querying.         // This is hacky but it's used so the AssemblyQualifiedName will always have correct         // version info.         Type t = typeof(State);         t = Type.GetType(t.AssemblyQualifiedName.Replace("State", table));          // Get lambda used to filter <table> where IsApproved is true.         object whereLamda = this.GetType()             .GetMethod(nameof(CreateWhereExpression), BindingFlags.NonPublic | BindingFlags.Instance)             .MakeGenericMethod(t)             .Invoke(this, new object[0]);          // Get lambda used to select <table>Name from <table>.         object selectLamda = this.GetType()             .GetMethod(nameof(CreateSelectExpression), BindingFlags.NonPublic | BindingFlags.Instance)             .MakeGenericMethod(t)             .Invoke(this, new object[] { table });          // Get the DbSet<T> for the <table>.         object set = _context.GetType()             .GetMethod("Set")             .MakeGenericMethod(t)             .Invoke(_context, new object [0]);          IEnumerable<MethodInfo> whereMethods = typeof(Enumerable)             .GetMethods().Where(m => m.Name == nameof(Enumerable.Where));          // Apply Where() method to DbSet.         object filteredApproved = whereMethods             .ElementAt(0)             .MakeGenericMethod(t)             .Invoke(set, new object[] { set, whereLamda });          IEnumerable<MethodInfo> selectMethods = typeof(Enumerable)             .GetMethods().Where(m => m.Name == nameof(Enumerable.Select));          // Apply Select() method to filtered query.         object r = selectMethods             .ElementAt(0)             .MakeGenericMethod(t, typeof(string))             .Invoke(filteredApproved, new object[] { filteredApproved, selectLamda });          return r as IEnumerable<string>;     }      private Func<T, string> CreateSelectExpression<T>(string tableName)     {         var param = Expression.Parameter(typeof(T));         var expr = Expression.Property(param, $  "{tableName}Name");          return Expression.Lambda<Func<T, string>>(expr, param).Compile();     }      private Func<T, bool> CreateWhereExpression<T>()     {         var param = Expression.Parameter(typeof(T));         var expr = Expression.Equal(             Expression.Property(param, "IsApproved"),             Expression.Constant(true));          return Expression.Lambda<Func<T, bool>>(expr, param).Compile();     } 

Currently working, but has issues:

  • Doesn’t run async like the old method does, looking for a “correct” way to implement this.
  • Getting the correct Where and Select methods from Reflection, I don’t like relying on ElementAt(). Both methods have overloads with 2 parameters.
  • Any and all other problems. Have I created a monster?