MS excel mentioned formula giving result true or false that should be a number


The result should be number instead of true or false can anyone has solution, except condition formatting because I’ve tried that the result still is same.

dnd 5e – Can True Polymorph be dispelled or reversed?

Yes or No (DM’s choice)

As stated before by Eric, RAW for Dispel Magic says “Choose one creature, object, or magical effect within range… On a successful check, the spell ends.”

So the DM has to arbitrate if the permanent status of True Polymorph is due to-

A) A self-sustaining magical effect that continually supports the new form. This supports this with the “…until 0 HP or dies” clause). In which case: Dispel, Detect Magic, Anti-magic Field, etc. will also have an effect on Polymorph.

B) The shift being akin to an instantaneous spell, which has already gone through it’s magical effect. This is equally valid since it is a transmutation of living, non-magical matter to a different non-magical matter result. In which case, only altering reality or recasting polymorph (note the changing CR/levels and loss of gear) may work. Reverting back wouldn’t be an option due to dispel, HP, death or non-epic magic.

dg.differential geometry – Is it true that $text{diam}(X, varepsilon g)$ is uniformly bounded?

Given a compact Riemannian manifold $X$ with a fixed metric $g$, we can consider a sequence of metrics $varepsilon g$. When $varepsilon to 0$, is it necessarily true that the diameter of $M$ with respect to $varepsilon g$ is uniformly bounded?

Naively, one might tend to think that the distance of two fixed points are tending to zero as the metric tends to zero. However, even if that is true, the diameter are not guaranteed to be bounded, let alone this claim might be wrong.

Are there any obvious counter examples?

nt.number theory – Prove this is true only when $s equiv pm r^{pm 1} pmod{q}$

Let us fix a positive integer $q$, and let us define two functions $P, Q: mathbb{N}^2 to mathbb{N}$ as follows:
$$ P(s,t) := sum_{j=1}^t leftlfloor frac{j (s-1) + t}{q} rightrfloor$$
$$ Q(s,t) := sum_{j=1}^t leftlceil frac{j (s+1) – t}{q} rightrceil$$

If we define the function $A_s(t) : mathbb{N} to mathbb{N}$ by:
$$ A_s(t) := P(s,t) – Q(s,t) $$

I claim that $A_s = A_r$ (as functions of $t$) if and only if one of the following is true:

  • $s equiv r pmod{q}$
  • $s equiv -r pmod{q}$
  • $sr equiv 1 pmod{q}$
  • $sr equiv -1 pmod{q}$

I do have a proof of both implications, but they are rather involved and a bit too technical. The hardest part is to show that $A_s = A_r$ implies one of the four bullets. I suspect that there must exist an easier argument to solve this. For example, with this notation one can deduce some straightforward identities such as:

$$P(-s,t) = -Q(s,t)$$

which helps to prove that the second bullet implies $A_s = A_r$. I am wondering if this is indeed a hard problem and technical stuff has to play a role in a proof or if I am missing a simpler proof. Even a simple proof of the fact that both the third or fourth bullet imply $A_s = A_r$ would be nice, since what I have is lengthy and ugly.

What happens if it returns true and why we need to return false

why they are returning flase

In the following code what happens if we return true

Is there true dedicated hosting with dedicated hardware or it's all scam?

so I recently found from TMD hosting that under Dedicated hosting they sold me actual VPS. I always thought that Dedicated means actual serv… | Read the rest of

zoom – Is it exactly true that doubling the focal length makes everything look twice as big?

Your intuition is right. To validate it, we can dig into basic high-school geometry.

Although a camera lens is actually a complex lens made from many elements, conceptually and mathematically for most practical purposes, this reduces to an ideal, where you can imagine a pinhole exactly a distance from the sensor equal to the focal length. Light might fall outside of the cone, but we don’t care about that since it won’t be recorded — so, the angle of that cone is the angle of view.

So, the high school geometry, coming up. Here’s an idealized diagram showing 35mm and 70mm focal lengths (imagine a top-down view):

diagram by me; cc0 but link back to this answer appreciated

The first thing to note is that in order to compare like-to-like, you need to measure distance from the “pinhole”, not from the sensor. But, as you are normally working at distances of meters instead of millimeters, this is normally negligible and not worth worrying about.
In this diagram, I’ve kept that lens pinhole at the same point and moved the sensor to zoom.

The gray line on the right represents our subject distance, at 6cm. Of course, 6m might be a more typical non-macro distance, and at that scale the difference between the alignment of the sensor or camera as a whole and the nominal center of the lens doesn’t matter; here it does, but that’s the price we pay for a diagram which shows detail and fits on a screen.

The important thing is that the field of view is a matter of “similar triangles”. Consider triangle ∆CDE — what you get with a 35mm lens. Triangle ∆FHE has the same angles — the size is different, and it’s obviously reflected, but we can see that angles are the same. Here’s those sets of triangles shaded for clarity:


and the ones corresponding to 70mm:


I’m only showing half the frame because it’s easier to think about right triangles, but this is also all holds up if you add in the bottom half to make isosceles triangles showing the whole angle of view. (With me, still?)

So, the question basically is: as we move the focal length from DE out to BE, what happens to the corresponding line at FH → GH? We can see from the construction that as we double the focal length, the gray field of view line halves — which supports your intuitive conclusion.

We can also back this up with math; we could go into figuring out the angles, but I think the most intuitive way is to reason about the similar triangles — remember, the rule is that the sides of these triangles are proportional to each other.

That means CD/DE = FH/EH. If we double DE, we’re multiplying one side of the equation by ½. We have to multiply the other side also by the same amount to keep the proportion, so CD/2×DE = FH/2×EH — but, we’re not interested in changing EH in this case (we’re keeping the subject at the same distance), so we can invert it: CD/2×DE = ½FH/EH.

Now, looking back at the diagram, 2×DE is the same as BE (because DE is 35mm and BE is 70mm), so CD/BE = ½FH/EH. We also know that AB is exactly equal to CD (because the sensor size is the same), so AB/BE = ½FH/EH.

And, looking at the blue triangles, we know that AB/BE = GH/EH. Soooo, since ½FH/EH and GH/EH are both are equal to AB/BE, we can say that GH/EH = ½FH/EH, which simplifies to GH=½FH — mathematically answering the question above.

And, remember, that ½ is because we doubled the focal length — it comes from 35mm ÷ 70mm. So, the formula generalizes to old ÷ new for any change in focal length.

so... (cc0)

Sometimes, people get confused because the angle ∠FEH (or ∠GEH) as a value in degrees does not scale linearly — it seems like it does at long focal lengths but goes all divergent for very short ones. But, if you follow that out to the width or height of the frame at a certain distance, you’ll find that that scaling follows this same simple math throughout. This isn’t really all that complicated; it’s just the nature of tangents.

Of course, this is all in the ideal sense. In the real world, there are some caveats:

  • First, at very close focus distances (macro distance), the difference between “distance to sensor” and “distance to focal length of lens” matters;
  • second, in the real world, focusing changes focal length of most lenses to some degree, so nothing is perfectly ideal; and
  • third, as you get to extremes like your 1mm lens example, it’s hard to get a rectilinear projection so… all assumptions are off. And, even for regular lenses, the projection isn’t exactly perfect; there will be distortions which affect this slightly.

Oh, and a bonus caveat: if you’re trying to use this for measurement, you probably shouldn’t, because lenses designed for photography are not labeled precisely and may vary from the nominal by 10% or more without anyone thinking anything of it.

Especially for Michael Clark :)

But, hand-waving those things aside, the important thing is: yes, amount of the frame filled by a subject of a certain size at a certain distance doubles as you double focal length.

Or to put it another way, idealized zoom is mathematically indistinguishable from idealized cropping and enlarging.

procedural generation – Translating conditions (“If A has B, then true”) into objects that satisfy them (“A has B”)

I have a system where I’m sifting through a large number and variety of objects in my game, looking for objects that match an arbitrary search criteria that can be simple or complex.

For example, suppose a Foo has three integer properties, A, B, and C. I might search the list of Foo objects three times. First, I want to find a Foo where A>5. Second, I might want to find a Foo where A<B or B=8. Third, I might want to find a Foo where A=2, B=6, C>A, and C<B. The point is that I could arbitrarily pass any of a very wide set of conditions into the search.

Now here’s my problem. In all cases, if I can’t find an item that matches these criteria, I want to create a new Foo that does match, and add it to the list of Foo objects.

The thing I’m wrestling with is figuring out an underlying system of representing conditions that allows me to then create an item that directly matches those conditions. So far I’ve got two ideas, neither of which I’m a fan of:

  • Repeatedly generate random Foo objects across the span of possible properties, until applying the criteria to one of them results in true. Given the possible permutations involved, this feels like an absolute performance nightmare, and would probably require a ton of caching logic to track what possibility spaces have already been tried.
  • Establish a list of individual conditions with isolated variables (such as a GreaterThan condition with the referenced property that indicates whether the property is A, B, or C; and the target value) and create a corresponding declaration (Make (property) a random value between (targetValue) and (propertyMax)). Not only is this incredibly tedious, but I’m also not really confident I understand how it would work, particularly in C# but more generally also. This feels like self-reading code and that’s something I have no experience with.

My question is, basically, what designs and techniques can I use to address this sort of issue – the need to create objects that match criteria, when those criteria could be arbitrary? Surely this has come up in other projects. What kinds of constraints or frameworks are applied to make this doable?

pathfinder 1e – How to find out true names?

I guess I cannot find true names in books.

Yes. Yes, you can.

With a lot of research.

If you lookup the rules for Binding Outsiders (from Ultimate Magic), we will see that you can research the true name of an outsider on old libraries. This a long and tricky job, because strong outsiders do not want their true name to be known, and thus they have many names that they are known for, as to mislead those attempting to obtain command over them.

To discover a single outsider’s true name, a spellcaster must spend at least a month in a library or on a quest of discovery to uncover occult mysteries and riddles hidden in the pages of books, scrolls, and glyphs written millennia ago, buried in ancient temples or found among the ravings of madmen’s spellbooks.

At the end of this month, the GM makes a Knowledge (planes) check for the character. The DC is 10 + the creature’s Hit Dice. The GM can increase the DC by +2, +5, or even +10, based on the power of the outsider or the circumstances of the true name search. A failure by 5 or more turns up false information that may expose researchers to unexpected dangers.

Each of the Book of the Damned campaign setting books (3 volumes total) also brings the true names of a few evil outsiders, along with things you can do to discover their names and have an easier time attempting to bargain with them.

Some of those tips, for generic outsiders, can be found on the SRD pages about Binding Demons and Binding Devils, for instance.

Laravel 8 – Quando utilizo o Auth::attempt ele sempre retorna false mesmo estando true

Já tentei de tudo, mas nada funciona. Eu tenho quase certeza que o motivo é que o nome padrão do attempt “password” não condiz com a o nome da coluna passwordhash,


namespace AppHttpControllersadmin;

use AppHttpControllersController;
use AppModelsUser;
use IlluminateHttpRequest;
use IlluminateSupportFacadesAuth;
use IlluminateSupportFacadesHash;

class LoginController extends Controller
    public function login(Request $request){
        $data =  $request->all();

            return 'logou';
            return 'naao logou';

Meu Model User:


namespace AppModels;

use IlluminateDatabaseEloquentFactoriesHasFactory;
use IlluminateDatabaseEloquentModel;

class User extends IlluminateFoundationAuthUser
    protected $table = "tb_user";
    protected $fillable = (
    public $timestamps = false;

Eu creio que vou precisar mudar esse padrão do Attempt “password” pra passwordhash, mas não faço a mínima ideia de como fazer. Ou pode até ser outra solução e eu não qual.

Desde já agradeço quem me ajudar.