text:
# Chapter 10 - Radical Expressions and Equations - 10-2 Simplifying Radicals - Lesson Check: 8

$\frac{\sqrt 3}{2}$

#### Work Step by Step

$\frac{3}{\sqrt 12}$ To simplify we need to get the square root in the numerator. We mutiply $\frac{3}{\sqrt 12}$ by $\frac{\sqrt 12}{\sqrt 12}$ $\frac{3}{\sqrt 12} \times \frac{\sqrt 12}{\sqrt 12}$ $\frac{3 x \sqrt 12}{\sqrt 12 x \sqrt 12}$ $\frac{3 \sqrt 12}{\sqrt 144}$ The $\sqrt 12$ has a perfect square of 2 so we take it out and we are left with $\sqrt 3$ $\frac{6 \sqrt 3}{\sqrt 144}$ Square root of 144 is 12. Because 12 x 12 = 144 $\frac{6 \sqrt 3}{12}$ We divide 6 by twelve which is 2. $\frac{\sqrt 3}{2}$

After you claim an answer you’ll have 24 hours to send in a draft. An editor will review the submission and either publish your submission or provide feedback.

format: plain


text:
# 5.6 Projectile motion on an incline  (Page 4/7)

 Page 4 / 7

## Coordinates in horizontal (x) and vertical (y) directions

This approach retains the coordinates used in the normal case (in which projectile returns to the same horizontal level). In this consideration, the description of projectile motion is same as normal case except that motion is aborted in the mid-air by the incline. Had incline been not there, the projectile would have continued with its motion as shown in the figure.

When the projectile is allowed to return to the projection level, then the point of return is (OQ,0), where OQ is the horizontal range. This position of point of return changes to a new point (x,y), specified by the angle of elevation “α” of the wedge with respect to horizontal as shown in the figure.

From the triangle OPQ,

$\mathrm{cos}\alpha =\frac{x}{OP}=\frac{x}{R}$

The range of the projectile is given by :

$⇒R=\frac{x}{\mathrm{cos}\alpha }$

The strategy here is to determine “x” i.e. “OQ” considering the motion as normal projectile motion. Thus, we shall first determine “x” and then using above relation, we obtain the relation for the range of flight along the incline. Now, considering motion in horizontal direction , we have :

$x=u\mathrm{cos}\theta XT$

where “T” is the time of flight of projectile motion on the incline. It is given as determined earlier :

$T=\frac{2u\mathrm{sin}\left(\theta -\alpha \right)}{g\mathrm{cos}\alpha }$

Substituting in the epression of “x”, we have :

$⇒x=\frac{u\mathrm{cos}\theta X2u\mathrm{sin}\left(\theta -\alpha \right)}{g\mathrm{cos}\alpha }$

$⇒x=\frac{{u}^{2}2\mathrm{sin}\left(\theta -\alpha \right)\mathrm{cos}\theta }{g\mathrm{cos}\alpha }$

We simplify this relation, using trigonometric relation as given here :

$\mathrm{sin}C-\mathrm{sin}D=2\mathrm{sin}\left(\frac{C-D}{2}\right)\mathrm{cos}\left(\frac{C+D}{2}\right)$

Comparing right hand side of the equation with the expression in the numerator of the equation of “x”, we have :

$C-D=2\theta -2\alpha$

$C+D=2\theta$

$⇒C=2\theta -\alpha$

$⇒D=\alpha$

Thus, we can write :

$⇒2\mathrm{sin}\left(\theta -\alpha \right)\mathrm{cos}\theta =\mathrm{sin}\left(2\theta -\alpha \right)-\mathrm{sin}\alpha$

Substituting the expression in the equation of “x”,

$⇒x=\frac{{u}^{2}}{g\mathrm{cos}\alpha }\left\{\mathrm{sin}\left(2\theta -\alpha \right)-\mathrm{sin}\alpha \right\}$

Using the relation connecting horizontal range “x” with the range on incline, “R”, we have :

$R=\frac{x}{\mathrm{cos}\alpha }$

$⇒R=\frac{{u}^{2}}{g{\mathrm{cos}}^{2}\alpha }\left\{\mathrm{sin}\left(2\theta -\alpha \right)-\mathrm{sin}\alpha \right\}$

Thus, we get the same expression for range as expected. Though the final expressions are same, but the understanding of two approaches is important as they have best fit application in specific situations.

## Projection down the incline

A typical projection down the incline is shown with a reference system in which “x” and “y” axes are directions along incline and perpendicular to incline. The most important aspect of the analysis of this category of projectile motion is the emphasis that we put on the convention for measuring angles.

The angle of projection and angle of incline both are measured from a horizontal line. The expression for the time of flight is obtained by analyzing motion in vertical directions. Here we present the final results without working them out as the final forms of expressions are suggestive.

1: Components of initial velocity

${u}_{x}=u\mathrm{cos}\left(\theta +\alpha \right)$

${u}_{y}=u\mathrm{sin}\left(\theta +\alpha \right)$

2: Components of acceleration

A stone propelled from a catapult with a speed of 50ms-1 attains a height of 100m. Calculate the time of flight, calculate the angle of projection, calculate the range attained
58asagravitasnal firce
Amar
water boil at 100 and why
what is upper limit of speed
what temperature is 0 k
Riya
0k is the lower limit of the themordynamic scale which is equalt to -273 In celcius scale
Mustapha
How MKS system is the subset of SI system?
which colour has the shortest wavelength in the white light spectrum
if x=a-b, a=5.8cm b=3.22 cm find percentage error in x
x=5.8-3.22 x=2.58
what is the definition of resolution of forces
what is energy?
Ability of doing work is called energy energy neither be create nor destryoed but change in one form to an other form
Abdul
motion
Mustapha
highlights of atomic physics
Benjamin
can anyone tell who founded equations of motion !?
n=a+b/T² find the linear express
أوك
عباس
Quiklyyy
Moment of inertia of a bar in terms of perpendicular axis theorem
How should i know when to add/subtract the velocities and when to use the Pythagoras theorem?
Centre of mass of two uniform rods of same length but made of different materials and kept at L-shape meeting point is origin of coordinate


text:
# ionization_balance

plasmapy.formulary.ionization.ionization_balance(n: Unit('1 / m3'), T_e: Unit('K'))

Return the average ionization state of ions in a plasma assuming that the numbers of ions in each state are equal.

Z_bal is the estimate average ionization level of a plasma in thermal equilibrium that balances the number density of ions in two different ionization states. Z_bal is derived from the Saha equation with the assumptions that the atoms are of a single species, are either hydrogenic or completely ionized, and that there is a balance between ionization and recombination, meaning that the number of atoms in either state are equal. The Saha equation and therefore Z_bal are more accurate when the plasma is at a high density and temperature.

$Z\_bal = \sqrt{\frac{k_B T_e}{E_H}} \sqrt{\ln{\frac{1}{4 n a_{0}^3} (\frac{k_B T_e}{π E_H})^{3/2}}} - \frac{1}{2}$

Where $$k_B$$ is the Boltzmann constant, $$a_0$$ is the Bohr radius, and $$E_H$$ is the ionization energy of Hydrogen

Aliases:

Parameters
Warns

UnitsWarning – If units are not provided, SI units are assumed.

Raises

Examples

>>> import astropy.units as u
>>> T_e = 5000 * u.K
>>> n = 1e19 * u.m ** -3
>>> ionization_balance(n, T_e)
<Quantity 0.274...>
>>> T_e = 50 * u.eV
>>> n = 1e10 * u.m ** -3
>>> ionization_balance(n, T_e)
<Quantity 12.615...>

Returns

Z – The average ionization state of the ions in the plasma assuming that the numbers of ions in each state are equal.

Return type

Quantity


text:
# Recursion Explained

Recursion (adjective: recursive) occurs when a thing is defined in terms of itself or of its type. Recursion is used in a variety of disciplines ranging from linguistics to logic. The most common application of recursion is in mathematics and computer science, where a function being defined is applied within its own definition. While this apparently defines an infinite number of instances (function values), it is often done in such a way that no infinite loop or infinite chain of references ("crock recursion") can occur.

## Formal definitions

In mathematics and computer science, a class of objects or methods exhibits recursive behavior when it can be defined by two properties:

• A simple base case (or cases) — a terminating scenario that does not use recursion to produce an answer
• A recursive step — a set of rules that reduces all successive cases toward the base case.

For example, the following is a recursive definition of a person's ancestor. One's ancestor is either:

• One's parent (base case), or
• One's parent's ancestor (recursive step).

The Fibonacci sequence is another classic example of recursion:

as base case 1,

as base case 2,

For all integers, .

Many mathematical axioms are based upon recursive rules. For example, the formal definition of the natural numbers by the Peano axioms can be described as: "Zero is a natural number, and each natural number has a successor, which is also a natural number."[1] By this base case and recursive rule, one can generate the set of all natural numbers.

Other recursively defined mathematical objects include factorials, functions (e.g., recurrence relations), sets (e.g., Cantor ternary set), and fractals.

There are various more tongue-in-cheek definitions of recursion; see recursive humor.

## Informal definition

Recursion is the process a procedure goes through when one of the steps of the procedure involves invoking the procedure itself. A procedure that goes through recursion is said to be 'recursive'.[2]

To understand recursion, one must recognize the distinction between a procedure and the running of a procedure. A procedure is a set of steps based on a set of rules, while the running of a procedure involves actually following the rules and performing the steps.

Recursion is related to, but not the same as, a reference within the specification of a procedure to the execution of some other procedure.

When a procedure is defined as such, this immediately creates the possibility of an endless loop; recursion can only be properly used in a definition if the step in question is skipped in certain cases so that the procedure can complete. Recursion comes in three forms: direct, indirect, and circular. Direct recursion is when a function (A) invokes itself (A references A); indirect recursion occurs when one function (A) invokes (B), function (B) invokes function (C), function (C) invokes (D), etc., until one of the functions in the chain invokes an earlier one. Circular recursion occurs when function (A) and function (B) invoke each other. If an infinite loop occurs in direct, indirect, or circular recursion, it is said to be the condition of "crock recursion." There are basically two ways to prevent crock recursion, either limit the number of times a function may reference itself, or place an absolute limit on the depth of function calls, e.g. if there is a depth limit of 50, any time a procedure calls another, a counter is increased; when it exits, that counter is decreased. Once the counter reaches the limit (in this case, 50) no further procedure calls are allowed; if any attempt to call a 51st function is made, the operation is terminated. Using a recursion limit prevents only crock recursion; placing a call limit, in addition to halting crock recursion, may have the side effect of preventing the execution of legitimate complex procedures which are deeply nested, but not recursive.

But even if it is properly defined, a recursive procedure is not easy for humans to perform, as it requires distinguishing the new from the old, partially executed invocation of the procedure; this requires some administration as to how far various simultaneous instances of the procedures have progressed. For this reason, recursive definitions are very rare in everyday situations.

## In language

Linguist Noam Chomsky, among many others, has argued that the lack of an upper bound on the number of grammatical sentences in a language, and the lack of an upper bound on grammatical sentence length (beyond practical constraints such as the time available to utter one), can be explained as the consequence of recursion in natural language.[3] [4]

This can be understood in terms of a recursive definition of a syntactic category, such as a sentence. A sentence can have a structure in which what follows the verb is another sentence: Dorothy thinks witches are dangerous, in which the sentence witches are dangerous occurs in the larger one. So a sentence can be defined recursively (very roughly) as something with a structure that includes a noun phrase, a verb, and optionally another sentence. This is really just a special case of the mathematical definition of recursion.

This provides a way of understanding the creativity of language—the unbounded number of grammatical sentences—because it immediately predicts that sentences can be of arbitrary length: Dorothy thinks that Toto suspects that Tin Man said that.... There are many structures apart from sentences that can be defined recursively, and therefore many ways in which a sentence can embed instances of one category inside another.[5] Over the years, languages in general have proved amenable to this kind of analysis.

Recently, however, the generally accepted idea that recursion is an essential property of human language has been challenged by Daniel Everett on the basis of his claims about the Pirahã language. Andrew Nevins, David Pesetsky and Cilene Rodrigues are among many who have argued against this.[6] Literary self-reference can in any case be argued to be different in kind from mathematical or logical recursion.[7]

Recursion plays a crucial role not only in syntax, but also in natural language semantics. The word and, for example, can be construed as a function that can apply to sentence meanings to create new sentences, and likewise for noun phrase meanings, verb phrase meanings, and others. It can also apply to intransitive verbs, transitive verbs, or ditransitive verbs. In order to provide a single denotation for it that is suitably flexible, and is typically defined so that it can take any of these different types of meanings as arguments. This can be done by defining it for a simple case in which it combines sentences, and then defining the other cases recursively in terms of the simple one.[8]

A recursive grammar is a formal grammar that contains recursive production rules.[9]

### Recursive humor

Recursion is sometimes used humorously in computer science, programming, philosophy, or mathematics textbooks, generally by giving a circular definition or self-reference, in which the putative recursive step does not get closer to a base case, but instead leads to an infinite regress. It is not unusual for such books to include a joke entry in their glossary along the lines of:

Recursion, see Recursion.[10]

A variation is found on page 269 in the index of some editions of Brian Kernighan and Dennis Ritchie's book The C Programming Language; the index entry recursively references itself ("recursion 86, 139, 141, 182, 202, 269"). Early versions of this joke can be found in Let's talk Lisp by Laurent Siklóssy (published by Prentice Hall PTR on December 1, 1975, with a copyright date of 1976) and in Software Tools by Kernighan and Plauger (published by Addison-Wesley Professional on January 11, 1976). The joke also appears in The UNIX Programming Environment by Kernighan and Pike. It did not appear in the first edition of The C Programming Language. The joke is part of the Functional programming folklore and was already widespread in the functional programming community before the publication of the aforementioned books.

Another joke is that "To understand recursion, you must understand recursion."[10] In the English-language version of the Google web search engine, when a search for "recursion" is made, the site suggests "Did you mean: recursion."[11] An alternative form is the following, from Andrew Plotkin: "If you already know what recursion is, just remember the answer. Otherwise, find someone who is standing closer to Douglas Hofstadter than you are; then ask him or her what recursion is."

Recursive acronyms are other examples of recursive humor. PHP, for example, stands for "PHP Hypertext Preprocessor", WINE stands for "WINE Is Not an Emulator" GNU stands for "GNU's not Unix", and SPARQL denotes the "SPARQL Protocol and RDF Query Language".

## In mathematics

### Recursively defined sets

See main article: Recursive definition.

#### Example: the natural numbers

See also: Closure (mathematics). The canonical example of a recursively defined set is given by the natural numbers:

0 is in

N

if n is in

N

, then n + 1 is in

N

The set of natural numbers is the smallest set satisfying the previous two properties.

In mathematical logic, the Peano axioms (or Peano postulates or Dedekind–Peano axioms), are axioms for the natural numbers presented in the 19th century by the German mathematician Richard Dedekind and by the Italian mathematician Giuseppe Peano. The Peano Axioms define the natural numbers referring to a recursive successor function and addition and multiplication as recursive functions.

#### Example: Proof procedure

Another interesting example is the set of all "provable" propositions in an axiomatic system that are defined in terms of a proof procedure which is inductively (or recursively) defined as follows:

• If a proposition is an axiom, it is a provable proposition.
• If a proposition can be derived from true reachable propositions by means of inference rules, it is a provable proposition.
• The set of provable propositions is the smallest set of propositions satisfying these conditions.

### Finite subdivision rules

See main article: Finite subdivision rule. Finite subdivision rules are a geometric form of recursion, which can be used to create fractal-like images. A subdivision rule starts with a collection of polygons labelled by finitely many labels, and then each polygon is subdivided into smaller labelled polygons in a way that depends only on the labels of the original polygon. This process can be iterated. The standard `middle thirds' technique for creating the Cantor set is a subdivision rule, as is barycentric subdivision.

### Functional recursion

A function may be recursively defined in terms of itself. A familiar example is the Fibonacci number sequence: F(n) = F(n − 1) + F(n − 2). For such a definition to be useful, it must be reducible to non-recursively defined values: in this case F(0) = 0 and F(1) = 1.

A famous recursive function is the Ackermann function, which, unlike the Fibonacci sequence, cannot be expressed without recursion.

### Proofs involving recursive definitions

Applying the standard technique of proof by cases to recursively defined sets or functions, as in the preceding sections, yields structural induction — a powerful generalization of mathematical induction widely used to derive proofs in mathematical logic and computer science.

### Recursive optimization

Dynamic programming is an approach to optimization that restates a multiperiod or multistep optimization problem in recursive form. The key result in dynamic programming is the Bellman equation, which writes the value of the optimization problem at an earlier time (or earlier step) in terms of its value at a later time (or later step).

### The recursion theorem

In set theory, this is a theorem guaranteeing that recursively defined functions exist. Given a set, an element of and a function, the theorem states that there is a unique function

F:\N\toX

(where

\N

denotes the set of natural numbers including zero) such that

F(0)=a

F(n+1)=f(F(n))

for any natural number .

#### Proof of uniqueness

Take two functions

F:\N\toX

and

G:\N\toX

such that:

F(0)=a

G(0)=a

F(n+1)=f(F(n))

G(n+1)=f(G(n))

where is an element of .

It can be proved by mathematical induction that for all natural numbers

Base Case: so the equality holds for .

Inductive Step: Suppose for some Then .

Hence implies .

By induction, for all

n\in\N

.

## In computer science

See main article: Recursion (computer science). A common method of simplification is to divide a problem into subproblems of the same type. As a computer programming technique, this is called divide and conquer and is key to the design of many important algorithms. Divide and conquer serves as a top-down approach to problem solving, where problems are solved by solving smaller and smaller instances. A contrary approach is dynamic programming. This approach serves as a bottom-up approach, where problems are solved by solving larger and larger instances, until the desired size is reached.

A classic example of recursion is the definition of the factorial function, given here in C code:

unsigned int factorial(unsigned int n)

The function calls itself recursively on a smaller version of the input and multiplies the result of the recursive call by, until reaching the base case, analogously to the mathematical definition of factorial.

Recursion in computer programming is exemplified when a function is defined in terms of simpler, often smaller versions of itself. The solution to the problem is then devised by combining the solutions obtained from the simpler versions of the problem. One example application of recursion is in parsers for programming languages. The great advantage of recursion is that an infinite set of possible sentences, designs or other data can be defined, parsed or produced by a finite computer program.

Recurrence relations are equations which define one or more sequences recursively. Some specific kinds of recurrence relation can be "solved" to obtain a non-recursive definition (e.g., a closed-form expression).

Use of recursion in an algorithm has both advantages and disadvantages. The main advantage is usually the simplicity of instructions. The main disadvantage is that the memory usage of recursive algorithms may grow very quickly, rendering them impractical for larger instances.

## In biology

Shapes that seem to have been created by recursive processes sometimes appear in plants and animals, such as in branching structures in which one large part branches out into two or more similar smaller parts. One example is Romanesco broccoli.[12]

## In art

The Russian Doll or Matryoshka doll is a physical artistic example of the recursive concept.[13]

Recursion has been used in paintings since Giotto's Stefaneschi Triptych, made in 1320. Its central panel contains the kneeling figure of Cardinal Stefaneschi, holding up the triptych itself as an offering.[14] This practice is more generally known as the Droste effect, an example of the Mise en abyme technique.

M. C. Escher's Print Gallery (1956) is a print which depicts a distorted city containing a gallery which recursively contains the picture, and so ad infinitum.[15]

## Bibliography

• Edsger W.. Dijkstra. Edsger W. Dijkstra. Recursive Programming. Numerische Mathematik. 2. 1. 1960. 312–318. 10.1007/BF01386232. 127891023.
• Book: Johnsonbaugh, Richard. Richard Johnsonbaugh . Discrete Mathematics . Prentice Hall . 2004 . 978-0-13-117686-7 .
• Book: Hofstadter, Douglas . Douglas Hofstadter . Gödel, Escher, Bach: an Eternal Golden Braid . Basic Books . 1999 . 978-0-465-02656-2 .
• Book: Shoenfield, Joseph R. . Joseph R. Shoenfield. Recursion Theory . registration . A K Peters Ltd . 2000 . 978-1-56881-149-9 .
• Book: Causey, Robert L. . Logic, Sets, and Recursion . registration . Jones & Bartlett . 2001 . 978-0-7637-1695-0 .
• Book: Cori, Rene . Lascar, Daniel . Pelletier, Donald H. . Recursion Theory, Gödel's Theorems, Set Theory, Model Theory . Oxford University Press . 2001 . 978-0-19-850050-6 .
• Book: Barwise, Jon. Moss, Lawrence S. . Jon Barwise. Vicious Circles . Stanford Univ Center for the Study of Language and Information . 1996 . 978-0-19-850050-6 . - offers a treatment of corecursion.
• Book: Rosen, Kenneth H. . Discrete Mathematics and Its Applications . McGraw-Hill College . 2002 . 978-0-07-293033-7 .
• Book: Cormen . Thomas H. . Charles E. . Leiserson . Ronald L. . Rivest . Clifford . Stein . Introduction to Algorithms . Mit Pr . 2001 . 978-0-262-03293-3 .
• Book: Kernighan, B. . Ritchie, D. . The C programming Language . Prentice Hall . 1988 . 978-0-13-110362-7 .
• Book: Stokey, Nancy . Robert Lucas . Edward Prescott . Recursive Methods in Economic Dynamics . Harvard University Press . 1989 . 978-0-674-75096-8.
• Book: Hungerford . Algebra . Springer. 1980. 978-0-387-90518-1., first chapter on set theory.

## Notes and References

1. Web site: Peano axioms mathematics. Encyclopedia Britannica. en. 2019-10-24.
2. Web site: Definition of RECURSIVE. www.merriam-webster.com. en. 2019-10-24.
3. Book: Pinker, Steven. The Language Instinct. 1994. William Morrow.
4. 10.1016/j.cognition.2004.08.004 . The faculty of language: What's so special about it? . 2005 . Pinker . Steven . Jackendoff . Ray . Cognition . 95 . 2 . 201–236 . 15694646. 10.1.1.116.7784 . 1599505 .
5. Web site: What Is Recursion in English Grammar?. Nordquist. Richard. ThoughtCo. en. 2019-10-24.
6. 10.1353/lan.0.0140 . Evidence and argumentation: A reply to Everett (2009) . 2009 . Nevins . Andrew . Pesetsky . David . Rodrigues . Cilene . Language . 85 . 3 . 671–681 . 16915455 . https://web.archive.org/web/20120106154616/http://web.mit.edu/linguistics/people/faculty/pesetsky/Nevins_Pesetsky_Rodrigues_2_Evidence_and_Argumentation_Reply_to_Everett.pdf . 2012-01-06.
7. Book: Drucker, Thomas . Perspectives on the History of Mathematical Logic . 4 January 2008 . Springer Science & Business Media . 978-0-8176-4768-1 . 110.
8. Barbara Partee and Mats Rooth. 1983. In Rainer Bäuerle et al., Meaning, Use, and Interpretation of Language. Reprinted in Paul Portner and Barbara Partee, eds. 2002. Formal Semantics: The Essential Readings. Blackwell.
9. .
10. Book: Hunter, David. Essentials of Discrete Mathematics. 2011. Jones and Bartlett. 494. 9781449604424.


text:
Documentation

## Parameterize Gain Schedules

Typically, gain-scheduled control systems in Simulink® use lookup tables or MATLAB Function blocks to specify gain values as a function of the scheduling variables. For tuning, you replace these blocks by parametric gain surfaces. A parametric gain surface is a basis-function expansion whose coefficients are tunable. For example, you can model a time-varying gain k(t) as a cubic polynomial in t:

k(t) = k0 + k1t + k2t2 + k3t3.

Here, k0,...,k3 are tunable coefficients. When you parameterize scheduled gains in this way, `systune` can tune the gain-surface coefficients to meet your control objectives at a representative set of operating conditions. For applications where gains vary smoothly with the scheduling variables, this approach provides explicit formulas for the gains, which the software can write directly to MATLAB Function blocks. When you use lookup tables, this approach lets you tune a few coefficients rather than many individual lookup-table entries, drastically reducing the number of parameters and ensuring smooth transitions between operating points.

### Basis Function Parameterization

In a gain-scheduled controller, the scheduled gains are functions of the scheduling variables, σ. For example, a gain-scheduled PI controller has the form:

`$C\left(s,\sigma \right)={K}_{p}\left(\sigma \right)+\frac{{K}_{i}\left(\sigma \right)}{s}.$`

Tuning this controller requires determining the functional forms Kp(σ) and Ki(σ) that yield the best system performance over the operating range of σ values. However, tuning arbitrary functions is difficult. Therefore, it is necessary either to consider the function values at only a finite set of points, or restrict the generality of the functions themselves.

In the first approach, you choose a collection of design points, σ, and tune the gains Kp and Ki independently at each design point. The resulting set of gain values is stored in a lookup table driven by the scheduling variables, σ. A drawback of this approach is that tuning might yield substantially different values for neighboring design points, causing undesirable jumps when transitioning from one operating point to another.

Alternatively, you can model the gains as smooth functions of σ, but restrict the generality of such functions by using specific basis function expansions. For example, suppose σ is a scalar variable. You can model Kp(σ) as a quadratic function of σ:

`${K}_{p}\left(\sigma \right)={k}_{0}+{k}_{1}\sigma +{k}_{2}{\sigma }^{2}.$`

After tuning, this parametric gain might have a profile such as the following (the specific shape of the curve depends on the tuned coefficient values and range of σ):

Or, suppose that σ consists of two scheduling variables, α and V. Then, you can model Kp(σ) as a bilinear function of α and V:

`${K}_{p}\left(\alpha ,V\right)={k}_{0}+{k}_{1}\alpha +{k}_{2}V+{k}_{3}\alpha V.$`

After tuning, this parametric gain might have a profile such as the following. Here too, the specific shape of the curve depends on the tuned coefficient values and ranges of σ values:

For tuning gain schedules with `systune`, you use a parametric gain surface that is a particular expansion of the gain in basis functions of σ:

`$K\left(\sigma \right)={K}_{0}+{K}_{1}{F}_{1}\left(n\left(\sigma \right)\right)+\dots +{K}_{M}{F}_{M}\left(n\left(\sigma \right)\right).$`

The basis functions F1,...,FM are user-selected and fixed. These functions operate on n(σ), where n is a function that scales and normalizes the scheduling variables to the interval [–1,1] (or an interval you specify). The coefficients of the expansion, K0,...,KM, are the tunable parameters of the gain surface. K0,...,KM can be scalar or matrix-valued, depending on the I/O size of the gain K(σ). The choice of basis function is problem-dependent, but in general, try low-order polynomial expansions first.

### Tunable Gain Surfaces

Use the `tunableSurface` command to construct a tunable model of a gain surface sampled over a grid of design points (σ values). For example, consider the gain with bilinear dependence on two scheduling variables, α and V:

`${K}_{p}\left(\alpha ,V\right)={K}_{0}+{K}_{1}\alpha +{K}_{2}V+{K}_{3}\alpha V.$`

Suppose that α is an angle of incidence that ranges from 0° to 15°, and V is a speed that ranges from 300 m/s to 700 m/s. Create a grid of design points that span these ranges. These design points must match the parameter values at which you sample your varying or nonlinear plant. (See Plant Models for Gain-Scheduled Controller Tuning.)

```[alpha,V] = ndgrid(0:5:15,300:100:700); domain = struct('alpha',alpha,'V',V);```

Specify the basis functions for the parameterization of this surface, α, V, and αV. The `tunableSurface` command expects the basis functions to be arranged as a vector of functions of two input variables. You can use an anonymous function to express the basis functions.

`shapefcn = @(alpha,V)[alpha,V,alpha*V];`

Alternatively, use `polyBasis`, `fourierBasis`, or `ndBasis` to generate basis functions of as many scheduling variables as you need.

Create the tunable surface using the design points and basis functions.

`Kp = tunableSurface('Kp',1,domain,shapefcn);`

`Kp` is a tunable model of the gain surface. `tunableSurface` parameterizes the surface as:

`${K}_{p}\left(\alpha ,V\right)={\overline{K}}_{0}+{\overline{K}}_{1}\overline{\alpha }+{\overline{K}}_{2}\overline{V}+{\overline{K}}_{3}\overline{\alpha }\overline{V},$`

where

`$\overline{\alpha }=\frac{\alpha -7.5}{7.5},\text{ }\overline{V}=\frac{V-500}{200}.$`

The surface is expressed in terms of the normalized variables, $\overline{\alpha },\overline{V}\in {\left[-1,1\right]}^{2}$ rather than in terms of α and V. This normalization, which `tunableSurface` performs by default, improves the conditioning of the optimization performed by `systune`. If needed, you can change the default scaling and normalization. (See `tunableSurface`).

The second input argument to `tunableSurface` specifies the initial value of the constant coefficient, K0. By default, K0 is the gain when all the scheduling variables are at the center of their ranges. `tunableSurface` takes the I/O dimensions of the gain surface from K0. Therefore, you can create array-valued tunable gains by providing an array for that input.

`Karr = tunableSurface('Karr',ones(2),domain,shapefcn);`

`Karr` is a 2-by-2 matrix in which each entry is a bilinear function of the scheduling variables with independent coefficients.

### Tunable Gain with Two Independent Scheduling Variables

This example shows how to model a scalar gain K with a bilinear dependence on two scheduling variables. You do so by creating a grid of design points representing the independent dependence of the two variables.

Suppose that the first variable α is an angle of incidence that ranges from 0 to 15 degrees, and the second variable V is a speed that ranges from 300 to 600 m/s. By default, the normalized variables are:

`$x=\frac{\alpha -7.5}{7.5},\phantom{\rule{1em}{0ex}}y=\frac{V-450}{150}.$`

The gain surface is modeled as:

`$K\left(\alpha ,V\right)={K}_{0}+{K}_{1}x+{K}_{2}y+{K}_{3}xy,$`

where ${K}_{0},...,{K}_{3}$ are the tunable parameters.

Create a grid of design points, (α,V), that are linearly spaced in α and V. These design points are the scheduling-variable values used for tuning the gain-surface coefficients. They must correspond to parameter values at which you have sampled the plant.

`[alpha,V] = ndgrid(0:3:15,300:50:600);`

These arrays, `alpha` and `V`, represent the independent variation of the two scheduling variables, each across its full range. Put them into a structure to define the design points for the tunable surface.

`domain = struct('alpha',alpha,'V',V);`

Create the basis functions that describe the bilinear expansion.

`shapefcn = @(x,y) [x,y,x*y]; % or use polyBasis('canonical',1,2)`

In the array returned by `shapefcn`, the basis functions are:

`$\begin{array}{c}{F}_{1}\left(x,y\right)=x\\ {F}_{2}\left(x,y\right)=y\\ {F}_{3}\left(x,y\right)=xy.\end{array}$`

Create the tunable gain surface.

`K = tunableSurface('K',1,domain,shapefcn);`

You can use the tunable surface as the parameterization for a lookup table block or a MATLAB Function block in a Simulink model. Or, use model interconnection commands to incorporate it as a tunable element in a control system modeled in MATLAB. After you tune the coefficients, you can examine the resulting gain surface using the `viewSurf` command. For this example, instead of tuning, manually set the coefficients to non-zero values and view the resulting gain.

```Ktuned = setData(K,[100,28,40,10]); viewSurf(Ktuned)```

`viewSurf` displays the gain surface as a function of the scheduling variables, for the ranges of values specified by `domain` and stored in the `SamplingGrid` property of the gain surface.

In your Simulink model, you model gain schedules using lookup table blocks, MATLAB Function blocks, or Matrix Interpolation blocks, as described in Model Gain-Scheduled Control Systems in Simulink. To tune these gain surfaces, use `tunableSurface` to create a gain surface for each block. In the `slTuner` interface to the model, designate each gain schedule as a block to tune, and set its parameterization to the corresponding gain surface. For instance, the `rct_CSTR` model includes a gain-scheduled PI controller, the `Concentration controller` subsystem, in which the gains `Kp` and `Ki` vary with the scheduling variable `Cr`.

To tune the lookup tables `Kp` and `Ki`, create a tunable surface for each one. Suppose that `CrEQ` is the vector of design points, and that you expect the gains to vary quadratically with `Cr`.

```TuningGrid = struct('Cr',CrEQ); ShapeFcn = @(Cr) [Cr , Cr^2]; Kp = tunableSurface('Kp',0,TuningGrid,ShapeFcn); Ki = tunableSurface('Ki',-2,TuningGrid,ShapeFcn);```

Suppose that you have an array `Gd` of linearizations of the plant subsystem, `CSTR`, at each of the design points in `CrEQ`. (See Plant Models for Gain-Scheduled Controller Tuning). Create an `slTuner` interface that substitutes this array for the plant subsystem and designates the two lookup-table blocks for tuning.

```BlockSubs = struct('Name','rct_CSTR/CSTR','Value',Gd); ST0 = slTuner('rct_CSTR',{'Kp','Ki'},BlockSubs); ```

Finally, use the tunable surfaces to parameterize the lookup tables.

```ST0.setBlockParam('Kp',Kp); ST0.setBlockParam('Ki',Ki);```

When you tune `STO`, `systune` tunes the coefficients of the tunable surfaces `Kp` and `Ki`, so that each tunable surface represents the tuned relationship between `Cr` and the gain. When you write the tuned values back to the block for validation, `setBlockParam` automatically generates tuned lookup-table data by evaluating the tunable surfaces at the breakpoints you specify in the corresponding blocks.

### Tunable Surfaces in MATLAB

For a control system modeled in MATLAB®, use tunable surfaces to construct more complex gain-scheduled control elements, such as gain-scheduled PID controllers, filters, or state-space controllers. For example, suppose that you create two gain surfaces `Kp` and `Ki` using `tunableSurface`. The following command constructs a tunable gain-scheduled PI controller.

`C0 = pid(Kp,Ki);`

Similarly, suppose that you create four matrix-valued gain surfaces `A`, `B`, `C`, `D`. The following command constructs a tunable gain-scheduled state-space controller.

`C1 = ss(A,B,C,D);`

You then incorporate the gain-scheduled controller into a generalized model of your entire control system. For example, suppose `G` is an array of models of your plant sampled at the design points that are specified in `Kp` and `Ki`. Then, the following command builds a tunable model of a gain-scheduled single-loop PID control system.

`T0 = feedback(G*C0,1);`

When you interconnect a tunable surface with other LTI models, the resulting model is an array of tunable generalized `genss` models. The design points in the tunable surface determine the dimensions of the array. Thus, each entry in the array represents the system at the corresponding scheduling variable value. The `SamplingGrid` property of the array stores those design points.

`T0 = feedback(G*Kp,1)`
```T0 = 4x5 array of generalized continuous-time state-space models. Each model has 1 outputs, 1 inputs, 3 states, and the following blocks: Kp: Parametric 1x4 matrix, 1 occurrences. Type "ss(T0)" to see the current value, "get(T0)" to see all properties, and "T0.Blocks" to interact with the blocks.```

The resulting generalized model has tunable blocks corresponding to the gain surfaces used to create the model. In this example, the system has one gain surface, `Kp`, which has the four tunable coefficients corresponding to K0, K1, K2, and K3. Therefore, the tunable block is a vector-valued `realp` parameter with four entries.

When you tune the control system with `systune`, the software tunes the coefficients for each of the design points specified in the tunable surface.

For an example illustrating the entire workflow in MATLAB, see the section “Controller Tuning in MATLAB” in Gain-Scheduled Control of a Chemical Reactor.


text:
TITLE

# Nonlinear elliptic equations with large supercritical exponents

AUTHOR(S)
Molle, Riccardo; Passaseo, Donato
PUB. DATE
June 2006
SOURCE
Calculus of Variations & Partial Differential Equations;Jun2006, Vol. 26 Issue 2, p201
SOURCE TYPE
DOC. TYPE
Article
ABSTRACT
The paper deals with the existence of positive solutions of the problem -? u=up in O, u=0 on ?O, where O is a bounded domain of $$\mathcal{R}^n$$ , n= 3, and p>2. We describe new concentration phenomena, which arise as p? +8 and can be exploited in order to construct, for p large enough, positive solutions that concentrate, as p? +8, near submanifolds of codimension 2. In this paper we consider, in particular, domains with axial symmetry and obtain positive solutions concentrating near (n-2)-dimensional spheres, which approach the boundary of O as p? +8. The existence and multiplicity results we state allow us to find positive solutions, for large p, also in domains which can be contractible and even arbitrarily close to starshaped domains (while no solution can exist if O is starshaped and $$p\ge {2n\over n-2}$$ , as a consequence of the Pohoï¿½aev's identity).
ACCESSION #
20378191

## Related Articles

• Reconstruction of 3D Human Facial Images Using Partial Differential Equations. Elyan, Eyad; Ugail, Hassan // Journal of Computers;Oct2007, Vol. 2 Issue 8, p1

One of the challenging problems in geometric modeling and computer graphics is the construction of realistic human facial geometry. Such geometry are essential for a wide range of applications, such as 3D face recognition, virtual reality applications, facial expression simulation and computer...

• Submanifolds with pointwise planar normal sections in a sphere. Li, Shi-jie // Journal of Geometry;2001, Vol. 70 Issue 1/2, p101

In this article, we prove that a submanifold of S[sup m] has pointwise 2- or 3-planar normal sections via the second standard immersion of S[sup m] if and only if it is totally geodesic in S[sup m].

• No symmetry advantage when object matching involves accidental viewpoints. Koning, Arno; Van Lier, Rob // Psychological Research;Jan2006, Vol. 70 Issue 1, p52

The presupposed advantage of symmetrical objects over asymmetrical objects was investigated in an object matching task, using accidental and non-accidental viewpoints. In addition, the accidental views could be symmetric or asymmetric. When two non-accidental views were presented, symmetrical...

• Hamiltonian stability of Lagrangian tori in toric Kï¿½hler manifolds. Hajime Ono // Annals of Global Analysis & Geometry;Jun2007, Vol. 31 Issue 4, p329

Abstractï¿½ï¿½Let (M,J,?) be a compact toric Khler manifold of dimC M=n and L a regular orbit of the T n-action on M. In the present paper, we investigate Hamiltonian stability of L, which was introduced by Y.-G. Oh (Invent. Math. 101, 501ï¿½519 (1990); Math. Z. 212, 175ï¿½192)...

• Decomposition and minimality of lagrangian submanifolds in nearly Kï¿½hler manifolds. Sch�fer, Lars; Smoczyk, Knut // Annals of Global Analysis & Geometry;Mar2010, Vol. 37 Issue 3, p221

We show that Lagrangian submanifolds in six-dimensional nearly Kï¿½hler (non-Kï¿½hler) manifolds and in twistor spaces Z4 n+2 over quaternionic Kï¿½hler manifolds Q4 n are minimal. Moreover, we prove that any Lagrangian submanifold L in a nearly Kï¿½hler manifold M splits into a...

• Null 2-type submanifolds of the Euclidean space E5 with non-parallel mean curvature vector. Dursun, Ugur // Journal of Geometry;Apr2007, Vol. 86 Issue 1/2, p73

Let M be a 3-dimensional submanifold of the Euclidean space E5 such that M is not of 1-type. We show that if M is flat and of null 2-type with constant mean curvature and non-parallel mean curvature vector then the normal bundle is flat. We also prove that M is an open portion of a 3-dimensional...

• Some slant submanifolds ofS-manifolds. Carriazo, Alfonso; Fernández, Luis M.; Hans-Uber, María Belén // Acta Mathematica Hungarica;Jun2005, Vol. 107 Issue 4, p267

We study some special types of slant submanifolds ofS-manifolds related to the second fundamental form of the immersion: totallyf-geodesic andf-umbilical, pseudo-umbilical and austere submanifolds. We also give several examples of such submanifolds.

• The Stability and Load-Carrying Capacity of Cylindrical Shells with Axisymmetric Dents. Gavrilenko, G. D.; Matsner, V. I. // International Applied Mechanics;Jul2002, Vol. 38 Issue 7, p861

The classical method of stability analysis and the reduced-stiffness method are used to evaluate the critical loads and the lower bounds of sensitivity to imperfections in buckling of longitudinally loaded elastic cylindrical shells with local imperfections in the form of axisymmetric...

• Solvability of Elliptic Boundary Value Problems without Standard Landesman-Lazer Condition. Han, Zhiqing // Acta Mathematica Sinica;2000, Vol. 16 Issue 2, p349

In this paper we prove a very general result concerning solvability of the resonant problem: Î”u + Î»[sub Îº] u + g(x, u) = h (x); u = 0, x âˆˆ âˆ‚ Î©, which immediately gives three generalized Landesman-Lazer conditions. The most interesting application of the general result is...

Share