## Luxury – How does Google Flights define classes?

Why is Norway's "Premium Cabin" displayed when I search for Premium Economy while Icelandair's "Saga Class" is displayed when I search for business? The equipment features are similar in both classes, but the Norwegian has a bigger seat pitch, so I would expect him to be in a better class, not the other way around.

Likewise, Azores Airlines 'executive class has similar amenities and smaller seating than LEVEL's Premium Economy, but Azores' executive class is listed as 'business on flights'.

What criteria does Google Flights use to classify different airline products?

## Equation Solution – Define a function with two solution solutions

I'm trying to combine the solutions from two NSolve and define a new function that I need to integrate.

Basically, I have two NSolve defined with the names eqpart and usol. I have assigned their solutions to three functions, xtot (Tx), ne (y) and T (y).

Then I defined neff (y_): = ne (y) * xtot (T (y)) and I try to integrate it as neff0 = NIntegrate (neff (y) * Lc * 2 * Pi * Rc ^ 2) * y , {y, ymin, ymax}) / (Pi *
Rc ^ 2 * Lc);

As an output, I have several bugs that say "eqpart … is neither a list of replacement rules nor a valid shipping table and therefore can not be used for replacement".

What am I doing wrong?

## Prologue: Define operators for propositional logic statements and add arguments to the list

I'm trying to define some operators that add the operators with the arguments and the lonely arguments to a list.

So far, I've defined the two operators I'll use, OR and NEGATION, but I do not know how to specify the actions they need to do next, create the lists, and add the operators and arguments to it.

``````:- op(400,fx,neg).
:- op(500,xfx,or).
``````

After that, I'm not sure how to add the operators and arguments to a list and merge all the lists.
According to the unification instruction in the manual, it would be something like this:

``````neg(X,()) :- union((X),(neg(X)),()).
or(X,Y,()) :- union((X),(or(X,Y)),()).
or(X,Y,()) :- union((Y),(or(X,Y)),()).
``````

Which does not send any errors, but how do I make the union of all the lists and how do I state that every lowercase letter can be used for the input.

An example of an input would be:

``````neg(a or b).
``````

And the expected output:

``````(neg(a or b), a or b, a, b)
``````

## dg.differential geometry – How do I define "interior space" for the unitary arch?

Let the unit be bow,

$${x in mathbb {R} ^ 2 | x_1 ^ 2 + x_2 ^ 2 = 1, x_1 geq 0, x_2 geq 0 }$$

There is something I found curious about the unitary bow:

• It has an empty heart, which is considered as a subset of $$mathbb {R} ^ 2$$

• It has an empty relative interior that is considered a subset of its affinity
Hull, which is again a subset of $$mathbb {R} ^ 2$$ and inherits the open
Balls.

But intuitively, the bow is not empty (everything in between can be considered interior). Is there a way to define the interior for these objects? (Unit sheet, embedded ball in the ortho, etc.)

## Puppet: Invoke define type in class from hiera

I want to create an install_package module that can be called multiple times, with packages defined in hiera. I know class is Skelton (can be called once), and define type is designed for my purpose.

I developed the following:
hiera.yaml

``````---
version: 5
hierarchy:
- name: "Common hierarchy level"
path: "common.yaml"

``````

./data/common.yaml

``````---
install_package::packages:
- vim
- logrotate

classes:
- install_package
``````

./module/install_package/manifest/init.pp

``````class install_package(
packages=(),
) {

define def_package()
notify{"package to install is \$name":}
}

def_package{ (\$packages): }
}
``````

Puppet returns "Error evaluating a resource statement, unknown resource type: & # 39; def_package & # 39;".

My question is how can I define packages that should be installed in variable (array) in /data/common.yaml, and then call install_package module several times with define type.

## Unity – How to dynamically define the X and Y values ​​of Vector2 based on a time value?

What I want to do is, the longer the player holds the screen, the longer the object will jump if the user releases the grip.

Here is my code:

``````private float timeBeginTap;
switch (touch.phase)
{

// Finger start touching the screen
case TouchPhase.Began:

print("Start tapping");

timeBeginTap = Time.time;
break;

// Finger leaving the screen
case TouchPhase.Ended:
//when finger release,the object jump

float timeHolding = Time.time - timeBeginTap;
Debug.Log(\$"The player1 touched the screen for {timeHolding} seconds.");

Vector2 jumpVelocity = new Vector2(timeHolding,timeHolding);
rb.velocity = rb.velocity + jumpVelocity;

break;
}
``````

So with the above code I can get the value like `0.6324167`.`0.423567` to the `timeHolding` This is the time the user keeps his finger on the screen.

And I can jump the object using the following code:

``````Vector2 jumpVelocity = new Vector2(timeHolding,timeHolding);
rb.velocity = rb.velocity + jumpVelocity;
``````

But the distance or "force" with which the object jumps is very small and makes no sense. That's why I try it with the following code:

``````float right = 5;
float up = 10;
Vector2 jumpVelocity = new Vector2(right*timeHolding,up*timeHolding);
rb.velocity = rb.velocity + jumpVelocity;
``````

Of course, with the above code, the distance is longer. But it feels like constant and not dynamic. Because the relationship between the X and Y values ​​of vector 2 is always constant.

So my question is

What is the right way to define the value of? `X and Y` to the `Vector2` Object based on the value of `Time`?

If I miss something, please guide me in the right direction. Thanks.

## If \$ E (X_ {n + 1} vert mathcal {F} _ {n}) leq X_ {n} + Y_ {n} \$ and \$ sum Y_ {n} < infty \$, how can I define? a Supermartingale?

To let $$X, Y$$ adapted, integrable processes and $$E (X_ {n + 1} vert mathcal {F} _ {n}) leq X_ {n} + Y_ {n}$$ and $$sum Y_ {n} < infty$$,

How can I define a Supermartingale by the above?

Background: I want to show that $$X_ {n}$$ converges a.s. up to a finite limit, with a holding time. It is defined as: $$tau: = inf {n: sum limits_ {i = 1} ^ {n} Y_ {i}> K }$$ for some $$K> 0$$

How can I show this? $$(X_ {n}) _ {n}$$ is a Supermartingale from the facts $$(*)$$ or do I have to define a new supermartingale?

## How do I define a condition that ends during the loop iteration of the Python list?

I'm having trouble with this Python practice problem:

Write a function, a sublist, that takes a list of numbers as parameters. Use a while loop in the function to return a sublist of the input list. The sublist should contain the same values ​​as the original list until it reaches number 5 (it should not contain the number 5).

Here's my try, but is_valid is never set to false.

``````def sublist(lst):
is_valid = True
ret_lst = ()
while is_valid:
for x in lst:
print(x, is_valid)
if x == 5:
is_valid == False
else:
ret_lst.append(x)

return ret_lst

lst = (1,2,3,4,5)
print(sublist(lst))
``````

## regular languages ​​- For a given DFA M, formally define an NFA N such that L (N) = {x in L (M) | x = invert (x)}

The English description of the question is (as I understand it) N accepts all strings accepted both palindromic (forward and backward) and M. After much effort and restlessness I am not convinced that such a string definition of N is even possible. I think as follows:

For example, suppose M is the DFA accepting the language $$(1 + 0) ^ *$$, Then the desired N would describe all palindromes about the language $${1, 0 }$$, However, such a language is not regular (I think). Is not such a formal definition possible because NFAs can only describe regular languages?

I may miss a subtle nuance in the question, but I believe that such a formal definition is simply not possible. Is my thinking right?

## Define notations by equation in latex

How can notations be defined in the equation that contain text so that they are well-aligned? for example

``````$$begin{equation} label{equa1} mathit{CAR} = frac{mathit{C}} {mathit{RWA_{c}}} geq 8% end{equation}$$
``````

Where:

C: = capital that must be reserved for regulatory purposes

RWA_c: = risk-weighted credit risk asset