text:
# Math Help - problem

1. ## problem

A team of 7 people is to be chosen from 12
couples. How many ways can a team of three men and four
women be chosen? How many ways can a team containing
no couple be chosen? How many ways can a team
containing exactly two couples be chosen?

my guess is for part 1 is: (12 choose 7) * (6 choose 3) * (6 choose 4)?

cant figure out the rest!

2. Hello, dannyshox!

Your counting is off . . .

A team of 7 people is to be chosen from 12 couples.

(a) How many ways can a team of 3 men and 4 women be chosen?
There are 12 couples: 12 men and 12 women.

Choose 3 men: . ${12\choose3} \:=\:\frac{12!}{3!\,9!} \:=\:220$ ways.

Choose 4 women: . ${12\choose4} \:=\:\frac{12!}{4!\,8!} \:=\:495$ ways.

Therefore: . $n(\text{3M, 4W}) \:=\:220\cdot 495 \:=\:108,\!900$ ways.

(b) How many ways can a team containing no couples be chosen?
I found no neat formula for this . . . I made an exhaustive list.

7 Men, 0 Women
. . . $n(\text{7M}) \;=\;{12\choose7}$ ways.

6 Men, 1 Woman
Choose 6 men: . ${12\choose6}$ ways.

The 1 woman must be chosen from the 6 women
. . who are not wives of the 6 men: . ${6\choose1}$ ways.
. . $n(\text{6M, 1W}) \:=\:{12\choose6}{6\choose1}$ ways.

5 Men, 2 Women
Choose 5 men: . ${12\choose5}$ ways.

The 2 women must be chosen from the 7 women
. . who are not wives of the 5 men: . ${7\choose2}$ ways.
. . $n(\text{5M, 2W}) \:=\:{12\choose5}{7\choose2}$ ways.

4 Men, 3 Women
Choose 4 men: . ${12\choose4}$ ways.

The 3 women must be chosen from the 8 women
. . who are not wives of the 4 men: . ${8\choose3}$ ways.
. . $n(\text{4M, 3W}) \:=\:{12\choose4}{8\choose3}$ ways.

3 Men, 4 Women
Choose 3 men: . ${12\choose3}$ ways.

The 4 women must be chosen from the 9 women
. . who are not wives of the 3 men: . ${9\choose4}$ ways.
. . $n(\text{3M, 4W}) \:=\:{12\choose3}{9\choose4}$ ways.

2 Men, 5 Women
Choose 2 men: . ${12\choose2}$ ways.

The 5 women must be chosen from the 10 women
. . who are not wives of the 2 men: . ${10\choose5}$ ways.
. . $n(\text{2M, 5W}) \:=\:{12\choose2}{10\choose5}$ ways.

1 Man, 6 Women
Choose 1 man: . ${12\choose1}$ ways.

The 6 women must be chosen from the 11 women
. . who are not wives of the 2 men: . ${11\choose6}$ ways.
. . $n(\text{1M, 6W}) \:=\:{12\choose1}{11\choose6}$ ways.

0 Man, 7 Women
Choose 7 women: . ${12\choose7}$ ways.

Now add them . . .

(c) How many ways can a team containing exactly two couples be chosen?

Choose 2 of the 12 men to be on the team: . ${12\choose2} \:=\:66$ ways.

There is 1 way that their wives are also on the team.

We have 4 people on the team.: 2M, 2W.
We must choose 3 more people from the other 4 men and 4 women
. . and include no couples.

There are 4 cases:

. . 3M, 0W: . ${4\choose3} \:=\:4$

. . 2M, 1W: . ${4\choose2}{2\choose1} \:=\:12$

. . 1M, 3W: . ${4\choose1}{3\choose2} \:=\:12$

. . 0M, 3W: . ${4\choose3} \:=\:4$

There are: . $4 + 12 + 12 + 4 \:=\:32$ ways.

Therefore: . $n(\text{exactly 2 couples}) \;=\;66\cdot32 \;=\;2112$ ways.

3. Originally Posted by Soroban
Hello, dannyshox!

Your counting is off . . .

There are 12 couples: 12 men and 12 women.

Choose 3 men: . ${12\choose3} \:=\:\frac{12!}{3!\,9!} \:=\:220$ ways.

Choose 4 women: . ${12\choose4} \:=\:\frac{12!}{4!\,8!} \:=\:495$ ways.

Therefore: . $n(\text{3M, 4W}) \:=\:220\cdot 495 \:=\:108,\!900$ ways.

I found no neat formula for this . . . I made an exhaustive list.

7 Men, 0 Women
. . . $n(\text{7M}) \;=\;{12\choose7}$ ways.

6 Men, 1 Woman
Choose 6 men: . ${12\choose6}$ ways.

The 1 woman must be chosen from the 6 women
. . who are not wives of the 6 men: . ${6\choose1}$ ways.
. . $n(\text{6M, 1W}) \:=\:{12\choose6}{6\choose1}$ ways.

5 Men, 2 Women
Choose 5 men: . ${12\choose5}$ ways.

The 2 women must be chosen from the 7 women
. . who are not wives of the 5 men: . ${7\choose2}$ ways.
. . $n(\text{5M, 2W}) \:=\:{12\choose5}{7\choose2}$ ways.

4 Men, 3 Women
Choose 4 men: . ${12\choose4}$ ways.

The 3 women must be chosen from the 8 women
. . who are not wives of the 4 men: . ${8\choose3}$ ways.
. . $n(\text{4M, 3W}) \:=\:{12\choose4}{8\choose3}$ ways.

3 Men, 4 Women
Choose 3 men: . ${12\choose3}$ ways.

The 4 women must be chosen from the 9 women
. . who are not wives of the 3 men: . ${9\choose4}$ ways.
. . $n(\text{3M, 4W}) \:=\:{12\choose3}{9\choose4}$ ways.

2 Men, 5 Women
Choose 2 men: . ${12\choose2}$ ways.

The 5 women must be chosen from the 10 women
. . who are not wives of the 2 men: . ${10\choose5}$ ways.
. . $n(\text{2M, 5W}) \:=\:{12\choose2}{10\choose5}$ ways.

1 Man, 6 Women
Choose 1 man: . ${12\choose1}$ ways.

The 6 women must be chosen from the 11 women
. . who are not wives of the 2 men: . ${11\choose6}$ ways.
. . $n(\text{1M, 6W}) \:=\:{12\choose1}{11\choose6}$ ways.

0 Man, 7 Women
Choose 7 women: . ${12\choose7}$ ways.

Now add them . . .

Choose 2 of the 12 men to be on the team: . ${12\choose2} \:=\:66$ ways.

There is 1 way that their wives are also on the team.

We have 4 people on the team.: 2M, 2W.
We must choose 3 more people from the other 4 men and 4 women
. . and include no couples.

There are 4 cases:

. . 3M, 0W: . ${4\choose3} \:=\:4$

. . 2M, 1W: . ${4\choose2}{2\choose1} \:=\:12$

. . 1M, 3W: . ${4\choose1}{3\choose2} \:=\:12$

. . 0M, 3W: . ${4\choose3} \:=\:4$

There are: . $4 + 12 + 12 + 4 \:=\:32$ ways.

Therefore: . $n(\text{exactly 2 couples}) \;=\;66\cdot32 \;=\;2112$ ways.

@Soroban - hi
For b)
An easy way - as there can't be a couple so first select 7couples from 12 couples. 12C7.
Now that you have 7 couples select either of the partner. i.e. 2^7ways.
So we have 12C7.2^7

solution to c) also appears wrong at following places plz

We must choose 3 more people from the other 4 men and 4 women
. . and include no couples.

1M, 3W: ${4\choose1}{3\choose2} \:=\:12$


text:
4.6k views

The recurrence relation that arises in relation with the complexity of binary search is:

1. $T(n) = 2T\left(\frac{n}{2}\right)+k, \text{ k is a constant }$

2. $T(n) = T\left(\frac{n}{2}\right)+k, \text{ k is a constant }$

3. $T(n) = T\left(\frac{n}{2}\right)+\log n$

4. $T(n) = T\left(\frac{n}{2}\right)+n$

| 4.6k views

It is B. searching for only one half of the list. leading to $T(n/2)$+ constant time in comparing and finding mid element.

by Boss (19.9k points)
edited by

(b) T(n)= T(n / 2)+ k , where k is constant

http://www.geeksforgeeks.org/binary-search/

by
answer is B in binary search once checked with middle value. we need to do the operation only with one half of the array.
by Boss (11k points)
0
sir, it means we always apply operation in the tree with in-order traversal because in-order is sorted

if elements in the list are 3,7,1,2,9 and they are asking to form a binary tree then we will first sort it in ascending order and then form a tree? but I think we make a tree with 3 as a parent and then right is 7 then left of 3 is 1 like this? A BIG confusion arises

option B is correct...

by Boss (41.4k points)
0
+1

https://gateoverflow.in/2444/gate1994_1-7

i selected option A

and worst case to search in BST is O(n)

Option B is may be for balanced BST

0
0
@akash

worst case for BST is O(n)
+1
I think, u are not reading question carefully. They are asking about Binary Search algorithm which is used in searching of elements in ordered lists..
0

Yeah! i know that

what if tree is ordered and only one sided

like this

+2

The question is about binary search not for binary search tree . hope u get the point ??

0

@papesh

Still I didn't get that

It is not always possible that we start search from middle element.

And the concepts are related to each other that's the reason I shown the BST.

It is Gate 1994 question

https://gateoverflow.in/2444/gate1994_1-7

0
They are asking about Binary search that is when array is already sorted with distinct element we can directly jump to middle and after comparing middle we can either go peft or go right we have to follow one path..

Ie T(n2) + k
0
it seems easy by using master theoram.

Its Option B.

Because, in binary search we reduce the search space into half at each comparison.

For more information check out link below... just to get an idea on how binary search works

https://www.flowerbrackets.com/binary-search-java/

Hope it helps!!!

by (61 points)
edited by
–1 vote
They are asking about Binary search that is when array is already sorted with distinct element we can directly jump to middle and after comparing middle we can either go peft or go right we have to follow one path..

Ie T(n2) + k
by Active (4k points)
Option B
by Active (2.8k points)

1
2

format: plain


text:
# 2020 AMC 12B Problems/Problem 7

## Problem

Two nonhorizontal, non vertical lines in the $xy$-coordinate plane intersect to form a $45^{\circ}$ angle. One line has slope equal to $6$ times the slope of the other line. What is the greatest possible value of the product of the slopes of the two lines?

$\textbf{(A)}\ \frac16 \qquad\textbf{(B)}\ \frac23 \qquad\textbf{(C)}\ \frac32 \qquad\textbf{(D)}\ 3 \qquad\textbf{(E)}\ 6$

## Solution 1 (complex)

Let the intersection point is the origin. Let $(a,b)$ be a point on the line of lesser slope. The mutliplication of $a+bi$ by cis 45. $(a+bi)(\frac{1}{\sqrt 2 }+i*\frac{1}{\sqrt 2 })=\frac{1}{\sqrt 2 }((a-b)+(a+b)*i)$ and therefore $(a-b, a+b)$ lies on the line of greater slope.

Then, the rotation of $(a,b)$ by 45 degrees gives a line of slope $\frac{a+b}{a-b}$.

We get the equation $\frac{6b}{a}=\frac{a+b}{a-b}\implies a^2-5ab+6b^2=(a-3b)(a-2b)=0$ and this gives our answer to be $\mathbf{(C)} \frac{3}{2}$.

~jeffisepic

## Solution 2 (vector products)

Intersect at the origin and select a point on each line to define vectors $\mathbf{v}_{i}=(x_{i},y_{i})$. Note that $\theta=45^{\circ}$ gives equal magnitudes of the vector products $$\mathbf{v}_1\cdot\mathbf{v}_2 = v_{1}v_{2}\cos\theta \quad\mathrm{and}\quad |\mathbf{v}_1\times\mathbf{v}_2| = v_{1}v_{2}\sin\theta .$$

Substituting coordinate expressions for vector products, we find $$\mathbf{v}_1\cdot\mathbf{v}_2 = |\mathbf{v}_1\times\mathbf{v}_2| \ \implies\ x_{1}x_{2}+y_{1}y_{2} = x_{1}y_{2}-x_{2}y_{1} .$$ Divide this equation by $x_{1}x_{2}$ to obtain $$1+m_{1}m_{2} = m_{2}-m_{1} ,$$ where $m_{i}=y_{i}/x_{i}$ is the slope of line $i$. Taking $m_{2}=6m_{1}$ , we obtain $$6m_{1}^{2}-5m_{1}+1 = 0 \ \implies\ m_{1} \in \{\frac{1}{3},\frac{1}{2}\} .$$ The latter solution gives the largest product of slopes $m_{1}m_{2} = 6m_{1}^2 = \frac{3}{2} . \quad \boxed{\textbf{(C)}}$

~fairpark

## Solution 3 (bash)

Place on coordinate plane. Lines are $y=mx, y=6mx.$ The intersection point at the origin. Goes through $(0,0),(1,m),(1,6m),(1,0).$ So by law of sines, $\frac{5m}{\sin{45^{\circ}}} = \frac{\sqrt{1+m^2}}{1/(\sqrt{1+36m^2})},$ lettin $a=m^2$ we want $6a.$ Simplifying gives $50a = (1+a)(1+36a),$ so $36a^2-13a+1=0 \implies 36(a-1/4)(a-1/9)=0,$ so max $a=1/4,$ and $6a=3/2 \quad \boxed{(C)}.$

Law of sines on the green triangle with the red angle (45 deg) and blue angle, where sine blue angle is $1/(\sqrt{1+36m^2})$ from right triangle w vertices $(0,0),(1,0),(1,6m).$

~ccx09

## Solution 4 (tan)

Let one of the lines have equation $y=ax$. Let $\theta$ be the angle that line makes with the x-axis, so $\tan(\theta)=a$. The other line will have a slope of $\tan(45^{\circ}+\theta)=\frac{\tan(45^{\circ})+\tan(\theta)}{1-\tan(45^{\circ})\tan(\theta)} = \frac{1+a}{1-a}$. Since the slope of one line is $6$ times the other, and $a$ is the smaller slope, $6a = \frac{1+a}{1-a} \implies 6a-6a^2=1+a \implies 6a^2-5a+1=0 \implies a=\frac{1}{2},\frac{1}{3}$. If $a = \frac{1}{2}$, the other line will have slope $\frac{1+\frac{1}{2}}{1-\frac{1}{2}} = 3$. If $a = \frac{1}{3}$, the other line will have slope $\frac{1+\frac{1}{3}}{1-\frac{1}{3}} = 2$. The first case gives the bigger product of $\frac{3}{2}$, so our answer is $\boxed{\textbf{(C)}\ \frac32}$.

~JHawk0224

## Solution 5 (matrix transformation)

Multiply by the rotation transformation matrix $\begin{bmatrix} \cos \theta & - \sin \theta\\ \sin \theta & \cos \theta \end{bmatrix}$ where $\theta = 45^{\circ}.$

## Solution 6 (Cheating)

Let the smaller slope be $m$, then the larger slope is $6m$. Since we want the greatest product we begin checking each answer choice, starting with (E).

$6m^2=6$.

$m^2=1$.

This gives $m=1$ and $6m=6$. Checking with a protractor we see that this does not form a 45 degree angle.

Using this same method for the other answer choices, we eventually find that the answer is $\boxed{\textbf{(C)}\ \frac32}$ since our slopes are $\frac12$ and $3$ which forms a perfect 45 degree angle.

## Solution 7

If you have this formula memorized then it will be very easy to do: If $\theta$ is the angle between two lines with slopes $m_1$ and $m_2$, then $\tan(\theta)=\frac{m_1-m_2}{1+m_1m_2}$.

Now let the smaller slope be $m$, thus the other slope is $6m$. Using our formula above: $$\tan(45^\circ)=\frac{6m-m}{1+6m^2} \implies 6m^2-5m+1=0 \implies (2m-1)(3m-1)=0.$$ Therefore the two possible values for $m$ are $\tfrac{1}{2}$ and $\tfrac{1}{3}$. We choose the larger one and thus our answer is $$6m^2=6 \cdot \frac{1}{4} = \frac{3}{2} \implies \boxed{\mathbf{(C)}}.$$

~AngelaLZ

## Video Solution

Two solutions https://youtu.be/6ujfjGLzVoE

~IceMatrix


text:
# How can we show that $C_c^\infty(\mathbb R)$ strongly separates points?

Let $$C_b(\mathbb R)$$ denote the set of bounded continuous function from $$\mathbb R$$ to $$\mathbb R$$. We say that $$M\subseteq C_b(\mathbb R)$$

1. separates points $$:\Leftrightarrow$$ $$\forall x,y\in\mathbb R:x\ne y\Rightarrow\exists f\in M:f(x)\ne f(y)\tag1$$
2. strongly separates points $$:\Leftrightarrow$$ $$\forall x\in\mathbb R,\delta>0:\exists k\in\mathbb N,\left\{f_1,\ldots,f_k\right\}\subseteq M:\inf_{y\::\:d(x,y)\:\ge\:\delta}\max_{1\le i\le k}|f_i(x)-f_i(y)|>0\tag2$$

How can we show that $$C_c^\infty(\mathbb R)$$ strongly separates points?

It's clear that $$C_c^\infty(\mathbb R)$$ separates points.

• Do you mean $C_b^\infty$ in the places you've written $C_c^\infty$? – Trevor Gunn Nov 28 '18 at 16:53
• Do you mean $f_i$ instead of $h_i$? – Paul Frost Nov 28 '18 at 16:55
• @PaulFrost Sorry, fixed that. – 0xbadf00d Nov 28 '18 at 16:56
• @TrevorGunn No, I mean $C_c^\infty$. – 0xbadf00d Nov 28 '18 at 16:56
• Cant you just take a single $f\in C^\infty_c(\mathbb R)$ with $f(x)=1$, $\mathrm{supp}(f)\subset B(x,\delta)$? Then you would have $f(x)-f(y)=1$ for $d(x,y)\geq\delta$. – Federico Nov 28 '18 at 16:58

Given $$x\in\mathbb R$$ and $$\delta>0$$, take a single function $$f\in C^\infty_c(\mathbb R)$$ with $$f(x)=1$$ and $$\mathrm{supp}(f)\subset B(x,\delta)$$.
Then $$f(x)-f(y)=1$$ for $$d(x,y)\geq\delta$$.


text:
# General class methods and attributes of the landlab.grid.hex module¶

Landlab’s hex/trigonal grids are implemented by the class HexModelGrid, which inherits from VoronoiDelaunayGrid. This text lists grid methods available for the class:

# Getting Information about a Grid¶

The following attributes, properties, and methods provide data about the grid, its geometry, and the connectivity among the various elements. Each grid element has an ID number, which is also its position in an array that contains information about that type of element. For example, the x coordinate of node 5 would be found at grid.node_x[5].

The naming of grid-element arrays is attribute*_at_*element, where attribute is the name of the data in question, and element is the element to which the attribute applies. For example, the property node_at_cell contains the ID of the node associated with each cell. For example, node_at_cell[3] contains the node ID of the node associated with cell 3. The attribute is singular if there is only one value per element; for example, there is only one node associated with each cell. It is plural when there are multiple values per element; for example, the faces_at_cell array contains multiple faces for each cell. Exceptions to these general rules are functions that return indices of a subset of all elements of a particular type. For example, you can obtain an array with IDs of only the core nodes using core_nodes, while active_links provides an array of IDs of active links (only). Finally, attributes that represent a measurement of something, such as the length of a link or the surface area of a cell, are described using _of_, as in the example area_of_cell.

## Information about the grid as a whole¶

 axis_name Get the name of each coordinate axis. axis_units Get units for each axis. from_dict(params) LLCATS: GINF hexplot(data[, data_label, color_map]) Create a plot of the grid elements. move_origin(origin) Changes the x, y values of all nodes. ndim Number of spatial dimensions of the grid. node_axis_coordinates(*args, **kwds) Get the coordinates of nodes along a particular axis. number_of_elements(name) Number of instances of an element. number_of_node_columns Number of node columns hex grid. number_of_node_rows Number of node rows in a rectangular-shaped and/or horizontally oriented hex grid. save(path[, clobber]) Save a grid and fields. size(group) Size of the arrays stored in a group.

 active_link_dirs_at_node Link flux directions at each node: 1=incoming flux, -1=outgoing flux, 0=no flux. active_neighbors_at_node Get list of neighbor node IDs. all_node_azimuths_map Get azimuths from every node to every other node. all_node_distances_map Get distances from every node to every other node. boundary_nodes Get array of boundary nodes. calc_distances_of_nodes_to_point(coord[, …]) Get distances for nodes to a given point. cell_area_at_node Cell areas in a nnodes-long array. cell_at_node Node ID associated with grid cells. closed_boundary_nodes Get array of closed boundary nodes. core_nodes Get array of core nodes. downwind_links_at_node(values[, bad_index]) Return an (nnodes, X) shape array of link IDs of which links are downwind of each node, according to values (array or field). fixed_gradient_boundary_nodes Get array of fixed gradient boundary nodes. fixed_value_boundary_nodes Get array of fixed value boundary nodes. link_at_node_is_downwind(values[, out]) Return a boolean the same shape as links_at_node() which flags links which are downwind of the node as True. link_at_node_is_upwind(values[, out]) Return a boolean the same shape as links_at_node() which flags links which are upwind of the node as True. link_dirs_at_node Link directions at each node: 1=incoming, -1=outgoing, 0=none. links_at_node Get links of nodes. neighbors_at_node Get neighboring nodes. node_at_cell Node ID associated with grid cells. node_at_core_cell Get array of nodes associated with core cells. node_at_link_head Get array of the node at each link head (to-node). node_at_link_tail Get array of the node at each link tail (from-node). node_axis_coordinates(*args, **kwds) Get the coordinates of nodes along a particular axis. node_is_boundary(ids[, boundary_flag]) Check if nodes are boundary nodes. node_x Get array of the x-coordinates of nodes. node_y Get array of the y-coordinates of nodes. nodes Get node ids for the grid. nodes_at_bottom_edge Get nodes along the bottom edge of a grid, if grid is rectangular. nodes_at_left_edge Get nodes along the left edge of a grid, if grid is rectangular. nodes_at_patch Get the four nodes at the corners of each patch in a regular grid. nodes_at_right_edge Get nodes along the right edge of a grid, if grid is rectangular. nodes_at_top_edge Get nodes along the top edge of a grid, if grid is rectangular. number_of_core_nodes Number of core nodes. number_of_links_at_node Number of links connected to each node. number_of_node_columns Number of node columns hex grid. number_of_node_rows Number of node rows in a rectangular-shaped and/or horizontally oriented hex grid. number_of_nodes Total number of nodes. number_of_patches_present_at_node Return the number of patches at a node without a closed node. open_boundary_nodes Get array of open boundary nodes. patches_at_node Return a (nnodes, max_voronoi_polygon_sides) array of patches at nodes. patches_present_at_node A boolean array, False where a patch has a closed node or is missing. set_nodata_nodes_to_closed(node_data, …) Make no-data nodes closed boundaries. set_nodata_nodes_to_fixed_gradient(…) Make no-data nodes fixed gradient boundaries. status_at_node Get array of the boundary status for each node. unit_vector_sum_xcomponent_at_node Get array of x-component of unit vector sums at each node. unit_vector_sum_ycomponent_at_node Get array of y-component of unit vector sums at each node. upwind_links_at_node(values[, bad_index]) Return an (nnodes, X) shape array of link IDs of which links are upwind of each node, according to values (field or array). x_of_node Get array of the x-coordinates of nodes. y_of_node Get array of the y-coordinates of nodes.

 active_faces Get array of active faces. face_at_link Get array of faces associated with links. faces_at_cell Return array containing face IDs at each cell. link_at_face Get links associated with faces. number_of_active_faces Total number of active faces. number_of_faces Total number of faces. number_of_faces_at_cell() Number of faces attached to each cell. width_of_face Width of grid faces. x_of_face Get array of the x-coordinates of face midpoints. y_of_face Get array of the y-coordinates of face midpoints.

 links_at_patch Returns the links forming each patch. nodes_at_patch Get the four nodes at the corners of each patch in a regular grid. number_of_patches Number of patches. number_of_patches_present_at_link Return the number of patches at a link without a closed node. number_of_patches_present_at_node Return the number of patches at a node without a closed node. patches_at_link Returns the patches adjoined to each link. patches_at_node Return a (nnodes, max_voronoi_polygon_sides) array of patches at nodes. patches_present_at_link A boolean array, False where a patch has a closed node or is missing. patches_present_at_node A boolean array, False where a patch has a closed node or is missing.

 number_of_corners Total number of corners.

# Data Fields in ModelGrid¶

ModelGrid inherits from the ModelDataFields class. This provides ~.ModelGrid, and its subclasses, with the ability to, optionally, store data values that are associated with the different types grid elements (nodes, cells, etc.). In particular, as part of ModelGrid.__init__(), data field groups are added to the ModelGrid that provide containers to put data fields into. There is one group for each of the eight grid elements (node, cell, link, face, core_node, core_cell, active_link, and active_face).

To access these groups, use the same methods as accessing groups with ~.ModelDataFields. ModelGrid.__init__() adds the following attributes to itself that provide access to the values groups:

 at_node at_cell at_link at_face at_patch at_corner

Each of these attributes returns a dict-like object whose keys are value names as strings and values are numpy arrays that gives quantities at grid elements.

## Create Field Arrays¶

ModelGrid inherits several useful methods for creating new data fields and adding new data fields to a ModelGrid instance. Methods to add or create a new data array follow the numpy syntax for creating arrays. The folowing methods create and, optionally, initialize new arrays. These arrays are of the correct size but a new field will not be added to the field:

 empty Uninitialized array whose size is that of the field. ones Array, initialized to 1, whose size is that of the field. zeros Array, initialized to 0, whose size is that of the field.

## Add Fields to a ModelGrid¶

Unlike with the equivalent numpy functions, these do not take a size argument as the size of the returned arrays is determined from the size of the ModelGrid. However, the keyword arguments are the same as those of the numpy equivalents.

The following methods will create a new array and add a reference to that array to the ModelGrid:

 add_empty Create and add an uninitialized array of values to the field. add_field Add an array of values to the field. add_ones Create and add an array of values, initialized to 1, to the field. add_zeros Create and add an array of values, initialized to 0, to the field. delete_field Erases an existing field. set_units Set the units for a field of values.

These methods operate in the same way as the previous set except that, in addition to creating a new array, the newly-created array is added to the ModelGrid. The calling signature is the same but with the addition of an argument that gives the name of the new field as a string. The additional method, add_field(), adds a previously allocation array to the ModelGrid. If the array is of the incorrect size it will raise ValueError.

## Query Fields¶

Use the following methods/attributes get information about the stored data fields:

 size Size of the arrays stored in a group. keys List of field names in a group. has_group Check if a group exists. has_field Check if a field is in a group. field_units Get units for a field. field_values Get values of a field. groups List of group names.

i.e., call, e.g. mg.has_field(‘node’, ‘my_field_name’)

# Gradients, fluxes, and divergences on the grid¶

Landlab is designed to easily calculate gradients in quantities across the grid, and to construct fluxes and flux divergences from them. Because these calculations tend to be a little more involved than property lookups, the methods tend to start with calc_.

 calc_diff_at_link(node_values[, out]) Calculate differences of node values over links. calc_flux_div_at_cell(unit_flux[, out]) Calculate divergence of link-based fluxes at cells. calc_flux_div_at_node(unit_flux[, out]) Calculate divergence of link-based fluxes at nodes. calc_grad_at_link(node_values[, out]) Calculate gradients of node values at links. calc_grad_at_patch(grid[, elevs, …]) Calculate the components of the gradient at each patch. calc_net_flux_at_node(unit_flux_at_links[, out]) Calculate net link fluxes at nodes. calc_slope_at_node(grid[, elevs, method, …]) Array of slopes at nodes, averaged over neighboring patches. calc_slope_at_patch(grid[, elevs, …]) Calculate the slope (positive magnitude of gradient) at patches. calc_unit_normal_at_patch(grid[, elevs]) Calculate and return the unit normal vector to a patch.

# Mappers¶

These methods allow mapping of values defined on one grid element type onto a second, e.g., mapping upwind node values onto links, or mean link values onto nodes.

 map_downwind_node_link_max_to_node(grid, …) Map the largest magnitude of the links carrying flux from the node to the node. map_downwind_node_link_mean_to_node(grid, …) Map the mean magnitude of the links carrying flux out of the node to the node. map_link_head_node_to_link(grid, var_name[, out]) Map values from a link head nodes to links. map_link_tail_node_to_link(grid, var_name[, out]) Map values from a link tail nodes to links. map_link_vector_sum_to_patch(grid, var_name) Map the vector sum of links around a patch to the patch. map_link_vector_to_nodes(q) Map data defined on links to nodes. map_max_of_link_nodes_to_link(grid, var_name) Map the maximum of a link’s nodes to the link. map_max_of_node_links_to_node(grid, var_name) Map the maximum value of a nodes’ links to the node. map_max_of_patch_nodes_to_patch(grid, var_name) Map the maximum value of nodes around a patch to the patch. map_mean_of_link_nodes_to_link(grid, var_name) Map the mean of a link’s nodes to the link. map_mean_of_patch_nodes_to_patch(grid, var_name) Map the mean value of nodes around a patch to the patch. map_min_of_link_nodes_to_link(grid, var_name) Map the minimum of a link’s nodes to the link. map_min_of_node_links_to_node(grid, var_name) Map the minimum value of a nodes’ links to the node. map_min_of_patch_nodes_to_patch(grid, var_name) Map the minimum value of nodes around a patch to the patch. map_node_to_cell(grid, var_name[, out]) Map values for nodes to cells. map_upwind_node_link_max_to_node(grid, var_name) Map the largest magnitude of the links bringing flux into the node to the node. map_upwind_node_link_mean_to_node(grid, var_name) Map the mean magnitude of the links bringing flux into the node to the node. map_value_at_downwind_node_link_max_to_node(…) Map the the value found in one link array to a node, based on the largest magnitude value of links carrying fluxes out of the node, found in a second node array or field. map_value_at_max_node_to_link(grid, …[, out]) Map the the value found in one node array to a link, based on the maximum value found in a second node field or array. map_value_at_min_node_to_link(grid, …[, out]) Map the the value found in one node array to a link, based on the minimum value found in a second node field or array. map_value_at_upwind_node_link_max_to_node(…) Map the the value found in one link array to a node, based on the largest magnitude value of links bringing fluxes into the node, found in a second node array or field.

# Boundary condition control¶

These are the primary properties for getting and setting the grid boundary conditions. Changes made to status_at_node() and status_at_node() will automatically update the conditions defined at other grid elements automatically.

 active_faces Get array of active faces. active_links Get array of active links. active_neighbors_at_node Get list of neighbor node IDs. boundary_nodes Get array of boundary nodes. closed_boundary_nodes Get array of closed boundary nodes. core_cells Get array of core cells. core_nodes Get array of core nodes. fixed_gradient_boundary_nodes Get array of fixed gradient boundary nodes. fixed_links Get array of fixed links. fixed_value_boundary_nodes Get array of fixed value boundary nodes. node_at_core_cell Get array of nodes associated with core cells. node_is_boundary(ids[, boundary_flag]) Check if nodes are boundary nodes. nodes_at_bottom_edge Get nodes along the bottom edge of a grid, if grid is rectangular. nodes_at_left_edge Get nodes along the left edge of a grid, if grid is rectangular. nodes_at_right_edge Get nodes along the right edge of a grid, if grid is rectangular. nodes_at_top_edge Get nodes along the top edge of a grid, if grid is rectangular. number_of_active_faces Total number of active faces. number_of_active_links Number of active links. number_of_core_cells Number of core cells. number_of_core_nodes Number of core nodes. number_of_fixed_links Number of fixed links. number_of_patches_present_at_link Return the number of patches at a link without a closed node. number_of_patches_present_at_node Return the number of patches at a node without a closed node. open_boundary_nodes Get array of open boundary nodes. set_nodata_nodes_to_closed(node_data, …) Make no-data nodes closed boundaries. set_nodata_nodes_to_fixed_gradient(…) Make no-data nodes fixed gradient boundaries. status_at_link Get array of the status of all links. status_at_node Get array of the boundary status for each node.

# Identifying node subsets¶

These methods are useful in identifying subsets of nodes, e.g., closest node to a point; nodes at edges.

 nodes_at_bottom_edge Get nodes along the bottom edge of a grid, if grid is rectangular. nodes_at_left_edge Get nodes along the left edge of a grid, if grid is rectangular. nodes_at_right_edge Get nodes along the right edge of a grid, if grid is rectangular. nodes_at_top_edge Get nodes along the top edge of a grid, if grid is rectangular.

# Surface analysis¶

These methods permit the kinds of surface analysis that you might expect to find in GIS software.

 calc_aspect_at_node(grid[, …]) Get array of aspect of a surface. calc_hillshade_at_node([alt, az, slp, asp, …]) Get array of hillshade. calc_slope_at_node(grid[, elevs, method, …]) Array of slopes at nodes, averaged over neighboring patches.

# Notes¶

It is important that when creating a new grid class that inherits from ModelGrid, to call ModelGrid.__init__() in the new grid’s __init__(). For example, the new class’s __init__ should contain the following code,

class NewGrid(ModelGrid):
def __init__(self, *args, **kwds):
ModelGrid.__init__(self, **kwds)
# Code that initializes the NewGrid

Without this, the new grid class will not have the at_* attributes.


text:
MathSciNet bibliographic data MR2024979 81T60 (81T13) Witten, E. Chiral ring of ${\rm Sp}(N)$${\rm Sp}(N)$ and ${\rm SO}(N)$${\rm SO}(N)$ supersymmetric gauge theory in four dimensions. Chinese Ann. Math. Ser. B 24 (2003), no. 4, 403–414. Article

For users without a MathSciNet license , Relay Station allows linking from MR numbers in online mathematical literature directly to electronic journals and original articles. Subscribers receive the added value of full MathSciNet reviews.


text:
IJS-FMF high-energy physics seminars

# Darius Faroughy: High-pT Semi-Leptonics

Europe/Ljubljana
https://zoom.us/j/3601731049?pwd=bVNQRjUxU2ExZ0cveWcxYXNUUGdjZz09 (Zoom)

### https://zoom.us/j/3601731049?pwd=bVNQRjUxU2ExZ0cveWcxYXNUUGdjZz09

#### Zoom

Description

At high-pT hadron colliders, the search for new phenomena in final state leptons is one of the most promising ways to probe for TeV scale BSM physics affecting semi-leptonic transitions. In this talk I discuss how current LHC searches in neutral and charged Drell-Yan production can produce competetive limits on generic BSM models that complement those coming from low-energy flavor physics. In particular, we describe how high-pT searches could ultimately discover, or rule out, some of the most promising UV models that explain the apparent violation of lepton flavor universality in B decays.


text:
# Basic question about $\sup_{x\neq 0}{} \frac{\|Ax\|}{\|x\|} = \sup_{\|x\| = 1}{\|Ax\|}$, $x \in\mathbb{R}^n$

I am having trouble with understanding the following definition while studying some basic things related with matrix norms:

For every matrix $A\in M_n(\mathbb{R})$

$$\sup_{x\neq 0}{} \frac{\|Ax\|}{\|x\|} = \sup_{\|x\| = 1}{\|Ax\|},\; x \in\mathbb{R}^n$$

Why we are taking $\|x\| = 1$? Is there any proof of above statement?

Added: Why to take sup in the definition of norm?

I need help to understand above mentioned fact.

Thank you very much.

• Notice that $Ax/\| x \| = A(x/\|x\|)$, and $x/\|x\|$ has norm 1, so it's equivalent to take the supremum over norm 1 vectors. May 16 '13 at 18:22
• It's also the sup of $\|Ax\|$ over $\|x\|\leq 1$. May 17 '13 at 12:14

$$\frac{ \|Ax\| }{\|x\|} = \left|\left| A \frac{x}{\|x\|} \right|\right|$$ Running through all $x \neq 0$ is equivalent to running through all $y:= \frac{x}{\|x\|}$ with $\| y \|=1$.

• Thanks for the answer. I was expecting little more explanation. Like why to take $\sup$? May 16 '13 at 18:32
• @monalisa Because this definition is equivalent with definition $\| A \| = \inf_M \{ M : \| Ax \| \leqslant M \| x \| \}$, when $A$ is linear operator. May 16 '13 at 19:03

As julien pointed out, what follows is not a proof that

$$\sup_{x\neq0}\frac{||Ax||}{||x||}=\sup_{||y||=1}||Ay||,\quad\quad(1)$$

it is a discussion about the consequences of $(1)$. For a proof of $(1)$ see MichaelNgelo's answer.

$(1)$ implies that if we know that a given vector achieves either of the two supremums in $(1)$, then we can deduce from it a vector that achieves the other supremum.

Specifically, $x^*$ is such that

$$\frac{||Ax^*||}{||x^*||}=\sup_{x\neq0}\frac{||Ax||}{||x||}\quad\quad(*)$$

if and only if $y^*:=\frac{x^*}{||x^*||}$ is such that

$$||Ay^*||=\sup_{||y||=1}||Ay||.\quad\quad(**)$$

The above is useful because it allows to compute one of the supremums by computing the other instead, in particular, we can substitute a supremum over $\mathbb{R}\backslash \{0\}$ with one over the unit sphere.

An easy way to argue the above is by contradiction. For example, one direction follows from:

Suppose that $x^*$ satisfies $(*)$, but $y^*:=\frac{x^*}{||x^*||}$ does not satisfy $(**)$. Then, there exists some $\hat{y}\neq y^*$ such that $||\hat{y}||=1$ and

$$||A\hat{y}||>||Ay^*||\Rightarrow \frac{||A\hat{y}||}{1}=\frac{||A\hat{y}||}{||\hat{y}||}>||Ay^*||=\left|\left|A\frac{x^*}{||x^*||}\right|\right|=\frac{||Ax^*||}{||x^*||}=\sup_{x\neq0}\frac{||Ax||}{||x||}$$

EDIT: The $\sup$ is taken in order to make the function $\sigma$, that maps from the vector space of real $n\times n$ matrices, $M_n(\mathbb{R})$, to $[0,\infty)$, and is defined as

$$\sigma(A):=\sup_{x\neq 0}\frac{||Ax||}{||x||},$$

be a norm (that is, satisfy the norm axioms) on $M_n(\mathbb{R})$. If we drop the sup and instead use a fixed $x$, then $\sigma$ doesn't satisfy the first axiom ($\sigma(A)=0\Leftrightarrow A=0)$ any more.

• @srijan thanks!
– jkn
May 16 '13 at 19:49
• nice explanation @jkn May 17 '13 at 4:07
• glad its of any use.
– jkn
May 17 '13 at 12:08


text:
# efficient mesh management?

## Recommended Posts

Hi, So i have my Mesh Objects of (semi-pseudo code):
class MeshObject {

LPD3DXMESH mesh;

}

MeshObject meshes[10];

and my function to load a mesh to it
void loadMesh() {

LPD3DXMESH mesh;

for(int i=0; i<10; i++)
meshes[i]->mesh = mesh;

}

So i wonder if adding the same mesh to each object will increase the meshes in memory? Should i use LPD3DXMESH *mesh; in my object class instead? Also will directx load the same file each time? I mean my function is telling it to, but does it really do it?

##### Share on other sites
LPD3DXMESH is already a pointer LP is the give away. So you're already store it as a pointer. So assinging it to each mesh object as you did is only making a reference to the mesh. It is only loaded and stored 1 time. Since you called Load 1 time, and are only copying references, not the mesh data.

This means though, that if you call meshes[0]->mesh->doSomething(), that it will effect all the other meshes, since they are the same mesh.

##### Share on other sites
that looks very good and useful

i have thought about keeping my meshes in a vector before

but what do i have to include to make it work?

my compiler stops at the first line.

##### Share on other sites
I'm sorry, i thought my original post was off track so i removed the code, here it is again, you'll need

#include <vector>
#include <map>
#include <string>
#include <boost/shared_ptr.hpp>

I wrote this very quickly, so it's untested, may not compile, and may be entirely useless/flawed.

std::map<std::string, boost::shared_ptr<Mesh> > meshes;std::vector<boost::shared_ptr<Mesh> > meshInstances;boost::shared_ptr<Mesh> LoadMesh(const std::string &path){  std::map<std::string, boost::shared_ptr<Mesh> >::iterator it;  it = meshes.find(path);  if (it == meshes.end()  {    //mesh not loaded yet    it = meshes.insert(std::pair<std::string, boost::shared_ptr<Mesh> >(path, boost::shared_ptr<Mesh>(new Mesh())));    D3dXLoadMesh(it->second.get());  }  return it->second;}void PopualteMeshInstances(){  for (int i = 0; i < 10; ++i)  {    meshInstances.push_back(LoadMesh("yo.mesh"));  }}

You'll probably want your mesh instance to look more like this:
struct MeshInstance{  Matrix ModelTransform;  boost::shared_ptr<MeshObject> Mesh;};std::vector<MeshInstance> meshInstances;

That way you can store a model transform with each instance.

##### Share on other sites
Quote:
 Original post by bzroomLPD3DXMESH is already a pointer LP is the give away. So you're already store it as a pointer. So assinging it to each mesh object as you did is only making a reference to the mesh. It is only loaded and stored 1 time. Since you called Load 1 time, and are only copying references, not the mesh data.This means though, that if you call meshes[0]->mesh->doSomething(), that it will effect all the other meshes, since they are the same mesh.

I'm sorry, my example wasn't considering that i'm actually calling the function multiple times and pass a file name to it.

In that case, will my MeshObject array actually hold pointers to one mesh and not 10 meshes (if the file name doesnt change)?

it would actually look like this

int i=0;for(i=0; i<10; i++)    loadMesh("test.x");i=0;void loadMesh(char* filename) {        LPD3DXMESH mesh;	LoadMeshFromFile(&mesh, filename);	meshes[i++]->mesh = mesh;}

##### Share on other sites

Yes that will load 10 duplicate copies of the mesh, and you should use a system as described in my previous post to only load each mesh once.

##### Share on other sites
Alright, my performace confirms this.. it's very bad right now :)

i will try to implement your code now.

##### Share on other sites
Ok this works absolutely gorgeous, except that i had to remove all the "boost" usage.

(i'm working on a school project and can't use non standard libraries).

Will the performance at run time decrease without using boost when i get the meshes from the list for rendering?

##### Share on other sites
No, boost is just a way to intelligently handle the life of the objects pointed to by pointers. while it will work, copying the pointers around as you are, it is VERY unsafe.

Imagine you added a destructor to the MeshObject which told directx to free the mesh that it was pointing to. If all 10 MeshObjects are pointing to the same mesh, and one of them gets destroyed, telling d3d to free the mesh, then they all lose their mesh.

Worse still, they all still think the mesh is still there, since they have a pointer to it. But truthfully it's been deleted out from under them. This is called a dangling reference. and you're very very close to a whole party of them :)

You can implement your own reference counted object that the MeshObjects can share, so that when the destructor is called, it only frees the mesh after there are no more references to it. But why go through all that trouble when boost::shared_ptr is there for you?

There may be some std variant, or you may be able to convince your teacher to let you use shared_ptr, since it's pretty much standard at this point.

##### Share on other sites
Ok thanks for shedding light on "boost".

This library doesn't come with windows or? i tried to include it but the compiler says he can't find it.

So here's my implementation so far:

I was a little lazy and use one list to save each mesh one time and just give my mesh objects pointers to the meshes in the list.

LPD3DXMESH* mesh;void ObjectManager::addObject(char *file, MeshObject* object)  std::map<std::string, LPD3DXMESH>::iterator it;  it = MeshList.find(file);	if (it == MeshList.end())	{		mesh = new LPD3DXMESH;		LoadMeshFromFile(mesh, file);		MeshList.insert(std::pair<std::string, LPD3DXMESH>(file, (*mesh)));		object->mesh = treemesh;	}	else	{		object->mesh = &(it->second);	}	scene->AttachChild(object);}

In the rendering i go through my object graph and the objects seem to store only one adress for each mesh (right now i'm using two meshes and only two addresses are shown in my render loop).

Is this implementation suitable or does it miss some benefits of your code? The performance increased by about 100 fps with this new implementation btw. The objects render correctly too.

##### Share on other sites
This code is technically correct, but it still suffers from the issue that i menitioned before regarding ownership. Who owns each mesh that is loaded? How/When do they get cleaned up?

Just to clarify i was only speaking of boost::shared_ptr, not boost itself. Boost is a suplimental code library written by very competant people. Lots of the things contained in the library have been considered for adding to the standard library.

It's not a part of windows or restricted to windows even. It's a seperate library that you can build for lots of platforms. It should be pretty easy to find a ton of info about it through google.

Actually your code is a bit off, you're storing pointers to pointers for no reason.

void ObjectManager::addObject(char *file, MeshObject* object){  std::map<std::string, LPD3DXMESH>::iterator it;  it = MeshList.find(file);	if (it == MeshList.end())	{                LPD3DXMESH newMesh;		LoadMeshFromFile(&newMesh, file);		MeshList.insert(std::pair<std::string, LPD3DXMESH>(file, newMesh));		object->mesh = newMesh;	}	else	{		object->mesh = it->second;	}	scene->AttachChild(object);}

.. is likely more appropriate.

Remember, LPD3DXMesh is already a pointer.

##### Share on other sites
ah yes, thanks, this works better.

i gotta tattoo that on my forehead - "LPD3DXMesh is already a pointer"

now i just need to modify my scene structure so i can actually delete my little objects again :)

##### Share on other sites
No need to burn it into your skin... just remember that 'LP' means "LONG POINTER". :-)

##### Share on other sites
I'm willing to bet your project has memory leaks galore, judging by the last sniplet. When you delete things you're going to want it to cascade down into the object structure.

If you write unsafe code (unclear ownership), that pretty much means "shiz gonna be f'd." Which is where the shared_ptr comes in and all his brother objects.

When you run your program, and have some kind of cycle going on, where objects are being deleted and added. Assuming that nothing has crashed yet, open the task manager and look at the memory consumption of your process. It should eventually peak out. If it continues to rise and rise and rise and rise.. There are issues. It may only rise when you reload a level.. but if you reload the level 100 times it might have risen a lot. This is an issue, an extreme one if you're machine has limited memory to begin with.

I'm saying good luck, i'm just also assuming that you're going to have issue..

My suggestion is that you study the boost shared_ptr and wikipedia pages on the subject and implement your own smart ptr. Test it properly, and then use it thoroughly.

Looks like you could at least use auto_ptr, but it doesnt give you shareing ability, it'd be like using boost::scoped_ptr. But boost::shared_ptr and boost::weak_ptr is where it's at i'm tellin ya :)

##### Share on other sites
yes, you're right, suddenly memory usage goes up and up...

i have no idea where this is coming from now haha

yes i'm a newbie at c++ and direct x and i'll probably ditch my concepts a dozen of times in the future.

edit: found the problem, some array wasnt deleted.

Oh yea, that boost::shared_ptr sounds promising. i'll look deeper into it and try to boost up my code :)

##### Share on other sites
Quote:
 Original post by Daniel Eyes, you're right, suddenly memory usage goes up and up...i have no idea where this is coming from now hahayes i'm a newbie at c++ and direct x and i'll probably ditch my concepts a dozen of times in the future.edit: found the problem, some array wasnt deleted.Oh yea, that boost::shared_ptr sounds promising. i'll look deeper into it and try to boost up my code :)

Boost can seem a little intimidating at first (it's pretty enormous as a whole), but trust me, once you get your hands on shared_ptr, you'll wonder how you ever lived without it.


text:
# Relation of speeds of Earth at extremities of orbit through force

I came across this article in my book where they had related the velocities of earth at the aphelion and at the perihelion . Their approach was

$$1)$$ conservation of angular momentum at the desired points

$$2)$$ conservation of energy at the desired points.

This method is completely fine but I tried to think about it on my own and tried to replace the second step with equating force separately at the desired points. Now if we take the aphelion to be of distance $$r_1$$ where the speed of earth is $$v_1$$ and perihelion to be of distance $$r2$$ where the speed of earth is $$v_2$$ , through $$1)$$ we get $$r_1v_1=r_2v_2$$

And through second we get

$$\frac{G(m_s)(m_e)}{(r_1)^2} = \frac{(m_e)(v_1)^2}{r_1}$$

and

$$\frac{G(m_s)(m_e)}{(r_2)^2} = \frac{(m_e)(v_2)^2}{r_2}$$

Which gives us $$G(m_s) = (r_1)(v_1)^2=(r_2)(v_2)^2$$

Using the first result in the second result we get $$v_1=v_2$$. Which is obviously very very wrong untill and unless the orbit would have been circular. Now my question is , where is the flaw because I am unable to identify the step/part where I am doing the mistake.

• $F = m\ v^2/r$ is only valid for circular motion. – Bill Watts Jun 6 at 20:30
• But , don't we calculate the values of speeds at different points in an elliptical orbit using $F=m/v^2/r$ and if not then how do we calculate speeds at these different points ?@Bill – TheChemist Jun 6 at 20:32
• The general 2 body problem is more complicated and a separate question. But no, we do not use the circular motion formula for elliptic motion. – Bill Watts Jun 6 at 20:37
• Ok so basically most books , in order to make calculations easier assume the orbit to be circular and hence we are able to appy the circular motion formula , right? – TheChemist Jun 6 at 20:38
• Very elementary books maybe. For elliptic motion you have a radial component as well as a tangential component for velocity except at the extremities. – Bill Watts Jun 6 at 20:41

To summarise the discussion in the comments , the formula $$F=\frac{GMm}{R^2}= \frac{mv^2}{R}$$ is only valid for circular orbits and is not valid for elliptical orbits , hence we are not able to relate the velocities of any two given points on the orbit via this method.


text:
Combinatorial Bayesian Optimization¶

In this article, we will study the methods concerning Bayesian Optimization on Discrete Spaces. In this literature review, we seek to compare the following papers, summarized below:

Paper Title Code Date Published
Mixed-Variable Bayesian Optimization (MiVaBo) No code published Dec 2019
Combinatorial Bayesian Optimization using the Graph Cartesian Product (COMBO) https://github.com/QUVA-Lab/COMBO Oct 2019
Bayesian Optimization of Combinatorial Structures (BOCS) https://github.com/baptistar/BOCS Oct 2018
Bayesian Optimization with Tree-structured Dependencies (BO-Tree Struct) No code published Aug 2017

Introduction¶

Most BO methods have been focused on continuous search spaces due to the underlying assumption of using GPs as the prior, which relies on the smoothness defined by a kernel to model the uncertainty. There have been attempts to tackle this problem simply using continous kernels, and augment the result to become discrete. However, some combinations of discrete variables are impossible configurations and it is not captured the model. It faces the problem of combinatorial explosion, as instead of modelling the structural dependencies, BO embed the discrete variables into a $\mathbb{R}^d$ box. These methods work, but heavily rely on the discretization used, for example the discretization granulaity: too small and the input space is large vs too large the input space may contain poorly performing values of continuous inputs.

Optimizations over structured domains was raised as an important open problems at NIPS 2017 Workshop.

Contrasting with traditional BO, real world problems can have a mix of both ordinal and categorical variables. This results in unique problems:

1. Problems have black-box objectives for which gradient-based optimizers are not amenable.
2. Have expensive evaluation procedures for which methods with low sample efficiency such as evolution, genetic algorithms are unsuitable.
3. Have noisy and highly non-linear objectives for which simple and exact solutions are inaccurate.

In summary, the important considerations to designing a successful mixed variable BO:

1. How to encode the relationships between the variables (both discrete and continuous), that allows information sharing
2. How to optimize the discrete variables (Select the next discrete values) w high sample and computational efficiency
3. How to encode the constraints between the variables, allowing the model to exploit them

Applications¶

We list the applications of combinatorial BO (The links are given for those with avaliable references):

1. Optimal chipset configuration
2. Optimal architecture of deep neural network
3. Optimization of compilers to embed software on hardware
4. Object location in images
5. Drugs discovery
6. Cross-validation of hyperparameters in mixed integer solvers
7. Fine-tune hyperparameters
8. Food safety Control
9. Model sparsification in multi-component systems
10. Deciding where to place bike stations among locations offered by the communal administration to optimize its utility.
11. Deciding on a deep neural network architecture where the parameters may depend on the number of layers
12. Tuning neural network - continuous variables: learning rate, momentum and discrete variables: kernel size, stride and padding.
13. Sensor placements

We focus on discussion of methods for optimization of black-box functions.

We list random search based methods, which are not designed to be sample efficient and may not converge to a global optimum:

1. Local Search: Random Optimization, Random Search, Hill Climbing, Simulated annealing, etc...)
1. Not sample efficient
2. Generally may not converge to global optimum (Sometimes convergence is guaranteed)
2. Evolutionary algorithms
1. Not sample efficient
2. Generally may not converge to global optimum (Sometimes convergence is guaranteed)

Related BO methods:

1. SMAC, which is a BO that uses random forests as a surrogate model, which accommodates for mixed variable inputs. However, there are limitations as the frequentist uncertainty estimate provided by RF may suffer from variance degradation.
1. Cannot handle general constraints over the discrete variables
2. TPE, which uses a non-parametric kernel density estimator to identify inputs that are likely to improve upon and unlikely to perform worse than the best input found so far.
1. Cannot handle general constraints over the discrete variables

Implementation ideas:

Other State of the art approaches¶

1. Hyperband, is a variant of random search that exploits cheap but less accurate approximations of the objective to dynamically allocate resources for function evaluations.
2. BOHB, is the model based counterpart of HB, based on TPE.
3. Arc-Kernel - first proposed by Hutter & Osborne(2013). A new kernel designed to encode information about which parameters are relevant in a given structure.

Problem Statement¶

Both COMBO and BO-Tree-Struct adopted the standard BO problem, with no explict distinction between discrete and continuous variables. We note that even though COMBO only handle discrete spaces (ie. $\{0,1\}^d$), the problem as stated by COMBO is the standard BO setting:

$$\min_{x\in\mathcal{X}} f(x)$$

Finding the global optimum of a black-box function over a search space $\mathcal{X}$.

BOCS defined the domain of $\mathcal{X}$ to be $\mathcal{D}$ which is discrete and structured. They focused specifically where the domain is

$$\mathcal{D}=\{0,1\}^d$$

Finally, MiVaBo defined the the problem with constraints and explictly seprated the discrete and continuous variables, including linear/quadratic constraints ($g^c, g^d$) into the problem statment.

$$\mathcal{X} \subseteq \mathcal{X}^c \times \mathcal{X}^d, g^c(x)\geq 0, g^d(x)\geq 0$$

Summary of methods¶

Methods compared¶

Title Key Idea Compared to
MiVaBo Decouples the continuous and discrete components of the function using feature expansion SMAC, Random Search, GP-UCB(rounding), GP-UCB-SA
COMBO Use a combinatorial graph to quantify smoothness on combinatorial search spaces SMAC, TPE, SA, BOCS
BOCS Uses regression model of order $2$ GP-EI, SMAC, PS, SA, Random Search, OLS
BO-Tree Struct Use a surrogate tree model where GPs are at the leafs Arc-Kernel, Independent, SMAC, Random Search, GP-Marginal

• Independent is a baseline that consider an independent GP for every leaf of BO-Tree Struct. ie. It takes into account the tree structure but does not allow any sharing of information across different paths.
• PSL Sequential Monte Carlo particle search is an evolutionary algorithm that maintains a population of candidate solutions
• OLS is Oblivious local search where it evaluates in every iteration all points with Hamming distance one from its current point and adopts the best.

Dataset compared¶

Title Dataset used
MiVaBo Tuning XGBoost parameters(10), Tuning VAE(28)
COMBO Contamination control(12 Binary), Ising sparsification(24), Branin(2), Pest Control(21), SAT(28,43,60), NAS(31)
BOCS Binary Quadratic Programming(10), Sparsification of Ising Models(24), Contamination Control(25), Areo-structural Multi-Component Problem(21)
BO-Tree Struct Synthetic Trees($\leq 17$), Neural Network(4 - but structural)

Contributions¶

In this section, we discuss the key contributions of each of the paper:

1. MiVaBo - Algorithm that efficiently optimizes (mixed) functions subject to constraints, relying on linear surrogate model that decouples using expressive feature expansion. First method to be able to handle constraints over discrete domains.
2. COMBO - Introduced combinatorial graphs to introduce smoothness on combinatorial spaces. Algorithm to scale to higher dimensional problems. Itroduced individual scale parameters for each variable, allowing the kernel to be more flexible.
3. BOCS - Approximate optimizer that borrows some ideas from convex optimization, on a model that captures the interaction of structural elements.
4. BO-Tree Struct - Leverage conditional dependencues between variables (Hyper param), leveraging a tree structured surrogate model with GPs at the leafs. Also acquisition function that exploits the tree structure and EI.

Method¶

In this section, we will provide a description of the key operating principle of each method with a comparison of the advantages and disadvantages.

MiVaBo¶

The method considers breaking down the problem into 2 distinct parts - discrete and continous parts. For the continous part, a randomized approximation of GP based on Monte Carlo integration is used (uses low effective dimensionality). For discrete parts (like BOCS), a second order expandsion of the discrete variables. Mixing them, both discrete and continous variables are stacked. The stacking would allow the each to be optimized seprately: discrete - binary integer quadratic program (using CPLEX, Gurobi, etc), continous - commonly used BO optimizers (L-BFGS, DIRECT). The optimization is done by iterating between optimizing the discrete and continous variables. This method converges to global optimum via looking at the problem from linear parameterized multi-armed bandits.

The modelling works like a framework, marrying discrete and continous using the following (d,c,m represents discrete, continous and mixed from the interaction of the 2 components): $$f(x) = \sum_{j\in \{d,c,m\}} {w^j\phi^j(x^j)}$$ The discrete and continous parts are implementations of existing methods that focus on discrete and continous respectively. The model handles the mixed variable in this manner, by stacking products of all pairwiuse combinations of features of the variable types resulting in $M_d \times M_c$ features: $$\phi^m(x^d, x^c) \triangleq [\phi^d_i(x^d)\cdot \phi^c_j(x^c)]^T_{1\leq i \leq M_d, 1\leq j \leq M_c}$$ For acquisition function, the authors proposed 2 schemes - alternating optimization and dual decomposition. Alternating optimization would be alternating between optimizing the discrete and continous variables conditioned on the other. Dual decomposition would apply Lagrangian optimization over $f(x) = \sum_{j\in \{d,c,m\}} {w^j\phi^j(x^j)}$, with theoretical properties.

Significance¶

1. No-regret convergence to global minimum
2. Flexible as the components can be changed (ie. the optimizations can be tweaked)
3. Claims to be the first mxed-variable BO method that enjoys theoretical guarantees.

Limitations¶

1. Proof does not really work on alternating optimization like used in the algorithm.
2. Feature expansion does not really work well in higher dimensional spaces and priors would need to incorprated.
3. Need to be converted to a string of binary Random Variables for non-binary discrete variables.

Method is similar to BOCS, but it is cited ambiguously.

COMBO¶

The method constructs the combinatorial graph from the discrete variables, by modelling the variables in a graph depending on the properties of the discrete variables (considering ordinal or categorical). A GP surrogate model is defined over the graph using Graph Fourier Transforms, specifically it uses ARD diffusion kernel to get around the intractability of computing the eigensystem from the graph.

The model works by first considering a ordered sub-graph for every ordinal variable and complete sub-graph for every categorical variable. Then, the cartesian product is computed over the sub-graphs. An illustration is given below. Then a kernel is defined over the graph structure using Graph Fourier Transforms (GFT). The next best $x$ is found by the following procedure:

1. Evaluating 20000 randomly selected vertices.
2. 20 vertices with highest acquisition values are used as initial points for acquisition function optimization.
3. Exploring acquisition values on adjacent vertices, the exploration continues recursively on the adjacent vertices until no neighbours' acquisition values are higher than at the current vertex. (Breadth-first local search)

The full algorithm is given below:

GFT can represent any graph signal as a linear combination of graph Fourier bases.

Significance¶

1. Performs implicit variable selection
2. Natural metric using Hamming distance on categorical spaces.
3. Able to scale to higher dimensions using ARD kernel

Limitations¶

1. Modelling is focused on fully discrete case
2. Unnatural metric using Hamming distance on ordinal spaces

Unnatural metric using Hamming distance on ordinal spaces, which should be modelled using a continous distribution instead. There will be much power that can be unlocked by considering continous distribution. The categorical spaces approach is correct, but not ordinal. Using GFT, maybe there would be some penalty, question is what is the penalty if it exist?

BOCS¶

The technique used is similar to the discrete part of MiVaBO; they have used second order modelling of the interactions which according to some papers produce a good trade off between expressiveness and the ease of training. The technique uses sparse Bayesian linear regression, instead of GPs. Finding the next best $x$, it finds an approximate optima, considering regularization.

The model works by using linear regression, shown below. In the paper they are careful to account for regularization, by sampling model parameters from the posterior over $\alpha$ and $\sigma^2$ (Noise). $$f_{\alpha}(x) = \alpha_0 + \sum_j{\alpha_j x_j} + \sum_{i,j>i}{\alpha_{i,j}x_i x_j}$$ For acquisition function, they find the bext best $x$ by solving the following. Note that $\lambda P(x)$ is for regularization; it can be defined differently to achieve different goals. In BOCS, the authors used the L1 Norm $||x||_1$ (another possible definition is L2 Norm). By expanding $P(x)$, we can solve a simple binary quadratic program of the expanded form. $$\arg\max_{x\in D} {f_{\alpha}(x)} - \lambda P(x)$$

Significance¶

1. Able to control the trade off between expressiveness and ease of training, mainly due to setting of 2nd order of interactions.
2. Able to handle sparse data

Limitations¶

1. (Comment from COMBO) Requires users to specify the highest order of interactions among categorical variables (Any higher order interactions are ignored), which restrict its applications to problems with low order interactions between variables
2. (Comment from COMBO) Parametric nature of the surrogatre model having excessively large number of parameters.
3. Model is inherently designed to be binary Variables only.

BO-Tree Struct¶

The method models the dependencies of the variables in the program into a decision tree, resulting from the insight that conditional dependencies between hyperparameters can be exploited. The method is tractable as there is a weight vector that would allow the model to couple inference for some paths but still be able to scale to higher-dimensionality. It introduce smoothness by using GPs at the leafs. The optimization to get the next $x$ is done by performing optimization to find the best path then finding the best $x$ on that path.

The model works by using linear functions $c^Tr$: $$y_i \sim N(g_{p_i}(x_i)+z_{p_i}^T c, \sigma^2)\\ c\sim N(0,\Sigma_c)\\ g_p(.)\sim GP$$ Here, $c$ is a weight matrix applied on the feature vector $r$ and $z$ is a binary mask that activates the weights if the inner node decision variables on the path to leaf node $p$. $r$ is used to encode both numerical and categorical parameters. The acquisition function is performed efficiently by using 2 steps, first finding the best path: $$p_* = \arg\max_{p\in P} \alpha\left(p\mid D_n\right)$$ Then, using $p_*$, find the next best $x$. $$x_* \in \arg\max_{x\in X_{p_*}} \alpha\left(x,p_*\mid D_n\right)$$

An illustration of functions with tree-structured conditional relationships. Each inner node is a binary variable, and a path in those trees represents successive binary decisions. The leaves contain univariate quadratic functions that are shifted by different constant terms.

Significance¶

1. Allows explicit setting of $c$, to allow the method to use some prior domain knowledge, so that the conditional relationships can be efficiently encoded. (ie. when $c=0$, it can be seen as an independent model, or we can define a prior for $c$)
2. Flexible on how the path and kernel can interact, can be changed to use other definitions.

Limitations¶

1. Fundamentally linear interactions, but can be extended. But not both?
2. Acquisition function can be intermediate, between what is proposed, vs: $$(x_*, p_*) \in \arg\max_{p\in P, x\in X_{p}} \alpha\left(x,p\mid D_n\right)$$

The interactions type are standard, which means its either linear or nonlinear interactions. There cannot be a setting that get both.

In [ ]:


text:
Home > Bit Error > Bit Error Rate Symbol Error Rate Qpsk

# Bit Error Rate Symbol Error Rate Qpsk

## Contents

The simulation of the communication system components using Communications System Toolbox™ is covered in other parts of this guide. He is a masters in communication engineering and has 7 years of technical expertise in channel modeling and has worked in various technologies ranging from read channel design for hard drives, Hope you agree to this perspective? By the way I have 6 days to prep Is 8:00 AM an unreasonable time to meet with my graduate students and post-doc? http://sovidi.com/bit-error/bit-error-rate-qpsk-qpsk.php

There have been many cases where the curve derived from the theoretical expression for the symbol error probability has been compared with the simulated curve for the bit error probability (and The bit-error rates of DBPSK and DQPSK are compared to their non-differential counterparts in the graph to the right. For eg, in QPSK we have the constellation points {1+j,-1+j,-1-j,1-j} which can be assigned bits {00, 01, 10, 11} respectively. Why?

## Bit Error Rate For Qpsk Matlab Code

Print Symbol Error Rate (SER) for QPSK (4-QAM) modulation by Krishna Sankar on November 6, 2007 Given that we have discussed symbol error rate probability for a 4-PAM modulation, let us hMod = comm.RectangularQAMModulator(M); % Use 16-QAM. Implementation The general form for BPSK follows the equation: s n ( t ) = 2 E b T b cos  ( 2 π f c t + π ( Reply nano686 October 7, 2008 at 8:55 pm Hi, I have to calculate SER and BER of 4 PSK in Rayleigh channel with 2 case: 1.

In order to assign the noise power, I have this expression: snrdb=[1:15] Eb = 1; % signal energy snr = 10^(snrdb/10); noise_power = E/snr; and I apply normally distributed Gaussian noise doi:10.1016/j.arcontrol.2016.08.003. ^ a b IEEE Std 802.11-1999: Wireless LAN Medium Access Control (MAC) and Physical Layer (PHY) Specifications — the overarching IEEE 802.11 specification. matlab qpsk share|improve this question edited Apr 17 '12 at 9:01 Dipan Mehta 4,12611342 asked Jan 19 '12 at 19:16 George migrated from electronics.stackexchange.com Jan 19 '12 at 20:32 This question Qpsk Bit Error Rate Extrapolating BER data beyond an order of magnitude below the smallest empirical BER value is inherently unreliable.For a full list of inputs and outputs for berfit, see its reference page.Example: Curve

Note the half symbol-period offset between the two component waves. Relationship Between Bit Error Rate And Symbol Error Rate In general, whether Es/N0 is same as SNR depends on the defintions used by each person. By convention, in-phase modulates cosine and quadrature modulates sine. Hence, each symbol error causes one bit out of bits to be in error.

Implementation The implementation of QPSK is more general than that of BPSK and also indicates the implementation of higher-order PSK. Ber Calculation For Qpsk With Matlab Code Changing the BPSK in OFDM to QPSK in OFDM case should have been reasonably straightforward. please help me Reply Krishna Sankar June 20, 2009 at 11:03 am @mya: I have not tried modeling CDMA. Please try the request again.

## Relationship Between Bit Error Rate And Symbol Error Rate

Black Box Network Services. For example, for BPSK (equation 8.2-20 in [1]):P2(d)=Q(2γbRcd)Hard DecisionFrom equations 8.2-33, 8.2-28, and 8.2-29 in [1], and equations 13.28, 13.24, and 13.25 in [6]:Pb<∑d=dfree∞adf(d)P2(d)whereP2(d)=∑k=(d+1)/2d(dk)pk(1−p)d−kwhen d is odd, andP2(d)=∑k=d/2+1d(dk)pk(1−p)d−k+12(dd/2)pd/2(1−p)d/2when d is even Bit Error Rate For Qpsk Matlab Code With more than 8 phases, the error-rate becomes too high and there are better, though more complex, modulations available such as quadrature amplitude modulation (QAM). Symbol Error Rate Vs Bit Error Rate EbNovec = EbNomin:1:EbNomax; % Vector of EbNo values numEbNos = length(EbNovec); % Number of EbNo values % Preallocate space for certain data.

You can assign each constellation point to take two points. click site Note the use of polar non-return-to-zero encoding. May I propose you to compute MSE in frequency domain. However, from the symbol error rate vs Eb/No plot, we know that for the same value of SNR per bit (Eb/No), the symbol error rate for QPSK is double that of Bpsk Bit Error Rate

SNR for some common modulation schemes Like all M-ary modulation schemes with M = 2b symbols, when given exclusive access to a fixed bandwidth, the channel capacity of any phase shift The binary data that is conveyed by this waveform is: 1 1 0 0 0 1 1 0. The increase in E b / N 0 {\displaystyle E_{b}/N_{0}} required to overcome differential modulation in coded systems, however, is larger - typically about 3dB. news So the effective representation of symbols in pi/4-QPSK is '00'=1+j (45 degrees), '01'=-1+j (135 degrees), '10' = -1-j (225 degrees) and '11'= 1-j (315 degrees).

Store the result of this step as rxsig for later use.Invoke the semianalytic function using the txsig and rxsig data from earlier steps. Ber Of Qpsk In Awgn Channel Matlab Code Well, regarding the noise removal with halfband width, may I try to argue as follows: even if we pass the full bandwidth, we will be ignoring the imaginary part of the Unfortunately, it can only be obtained from: P s = 1 − ∫ − π M π M p θ r ( θ r ) d θ r {\displaystyle P_{s}=1-\int _{-{\frac

## As a result, the probability of bit-error for QPSK is the same as for BPSK: P b = Q ( 2 E b N 0 ) . {\displaystyle P_{b}=Q\left({\sqrt {\frac {2E_{b}}{N_{0}}}}\right).}

This example is a variation on the example in Example: Using the Semianalytic Technique, but it is tailored to use BERTool instead of using the semianalytic function directly.Running the Semianalytic ExampleTo If the probability of up-down or left-right error is small (Pe) then the probability of diagonal error is Pe^2 which is much less. In the figure, it is assumed that the signal starts with zero phase, and so there is a phase shift in both signals at t = 0 {\displaystyle t=0} . Symbol Error Rate And Bit Error Rate However, with a Gray coded bit mapping the bits assigned to the constelltion points {1+j,-1+j,-1-j,1-j} can be {00, 01, 11, 10} respectively.

These behaviors reflect their integration:If you select a data set in the data viewer, BERTool reconfigures the tabs to reflect the parameters associated with that data set and also highlights the In other, the base is 10. How is that related to SNR parameter? http://sovidi.com/bit-error/bit-error-rate-equation-for-qpsk.php Problem?

Barry, Edward A. Please try the request again. Run txsig through a noiseless channel. The two carrier waves are a cosine wave and a sine wave, as indicated by the signal-space analysis above.

High definition programming is delivered almost exclusively in 8PSK due to the higher bitrates of HD video and the high cost of satellite bandwidth.[6] The DVB-S2 standard requires support for both The function is viterbisim, one of the demonstration files included with Communications System Toolbox software.To run this example, follow these steps:Open BERTool and go to the Monte Carlo tab. (The default Generate message signal of length >= M^L. Reply Krishna Sankar November 8, 2009 at 7:45 am @dhanabalu: Thanks Reply KKK October 1, 2009 at 7:18 pm NEED THE PROGRAM FOR CALCUKATING BIT ERROR RATE FOR MARY PSK

Perror for s0 = erc(sqrt(Es/2No)) (remains same) Perror for s1 = erc(sqrt(Es/2No)) - (1/2)erc(sqrt(Es/2No)) = (1/2)erc(sqrt(Es/2No)) Similiarly Perror for s3 = (1/2)erc(sqrt(Es/2No)) Total symbol error probability = 1/3*erc(sqrt(Es/2No)) + (1/3)*(1/2)erc(sqrt(Es/2No)) + Thank you Reply Richard Mayo October 8, 2008 at 3:54 pm Sorry, I mean 3/4. After you create a function or model that simulates the system, BERTool iterates over your choice of Eb/N0 values and collects the results.Plot one or more BER data sets on a Reply Krishna Sankar October 11, 2008 at 1:03 pm @Micman: You can use this post for finding the symbol error rate for QPSK.

Modulation typeThese parameters describe the modulation scheme you used earlier in this procedure. ISBN0-07-113814-5. This lowers the dynamical range of fluctuations in the signal which is desirable when engineering communications signals. Related posts: Symbol Error Rate (SER) for 16-QAM Symbol Error Rate for 16PSK Symbol Error Rate (SER) for 4-PAM Comparing 16PSK vs 16QAM for symbol error rate Tagged as: AWGN, PSK,

This shows the points in the complex plane where, in this context, the real and imaginary axes are termed the in-phase and quadrature axes respectively due to their 90° separation. The commands below illustrate the difference between symbol errors and bit errors in other situations. In ur program, If you adjust the program for dB more than 20, the error will be zero then theory and simulation do nor follow each other What is the reason? txsig = modsig; % No filter in this example % Step 4.

The two signal components with their bit assignments are shown at the top, and the total combined signal at the bottom. hChan.SignalPower = (txsig'*txsig)/length(txsig); % Calculate and % assign signal power rxsig = step(hChan,txsig); % Add noise. The symbol error rate for 4-QAM modulation, derived in the post, symbol error rate for 4-QAM (QPSK) is given as, Click here for Matlab simulation of symbol error probability with 4QAM


text:
# American Institute of Mathematical Sciences

## Random Möbius dynamics on the unit disc and perturbation theory for Lyapunov exponents

 Department Mathematik, Friedrich-Alexander-Universität Erlangen-Nürnberg, Cauerstraße 11, 91058 Erlangen, Germany

Received  August 2020 Revised  January 2021 Published  April 2021

Randomly drawn $2\times 2$ matrices induce a random dynamics on the Riemann sphere via the Möbius transformation. Considering a situation where this dynamics is restricted to the unit disc and given by a random rotation perturbed by further random terms depending on two competing small parameters, the invariant (Furstenberg) measure of the random dynamical system is determined. The results have applications to the perturbation theory of Lyapunov exponents which are of relevance for one-dimensional discrete random Schrödinger operators.

Citation: Florian Dorsch, Hermann Schulz-Baldes. Random Möbius dynamics on the unit disc and perturbation theory for Lyapunov exponents. Discrete & Continuous Dynamical Systems - B, doi: 10.3934/dcdsb.2021076
##### References:
 [1] P. Bougerol and J. Lacroix, Products of Random Matrices with Applications to Schrödinger Operators, Birkhäuser, Boston, 1985. doi: 10.1007/978-1-4684-9172-2.  Google Scholar [2] Y. Benoist and J.-F. Quint, Random Walks on Reductive Groups, Springer, Cham, 2016. doi: 10.1007/978-3-319-47721-3.  Google Scholar [3] A. Bovier and A. Klein, Weak disorder expansion of the invariant measure for the one-dimensional Anderson model, J. Statist. Phys., 51 (1988), 501-517.  doi: 10.1007/BF01028469.  Google Scholar [4] R. Carmona and J. Lacroix, Spectral Theory of Random Schrödinger Operators, Birkhäuser, Basel, 1990. doi: 10.1007/978-1-4612-4488-2.  Google Scholar [5] B. Derrida and E. J. Gardner, Lyapunov exponent of the one dimensional Anderson model: Weak disorder expansion, J. Physique, 45 (1984), 1283-1295.  doi: 10.1051/jphys:019840045080128300.  Google Scholar [6] T.-C. Dinh, L. Kaufmann and H. Wu, Products of random matrices: A dynamical point of view, Pure and Applied Mathematics Quarterly, 2020, https://www.intlpress.com/site/pub/pages/journals/items/pamq/_home/acceptedpapers/index.php. Google Scholar [7] F. Dorsch and H. Schulz-Baldes, Random perturbations of hyperbolic dynamics, Electronic J. Prob., 24 (2019), 23 pp. doi: 10.1214/19-ejp340.  Google Scholar [8] F. Dorsch and H. Schulz-Baldes, Pseudo-gaps for random hopping models, J. Phys. A, 53 (2020), 185201, 21 pp. doi: 10.1088/1751-8121/ab5e8c.  Google Scholar [9] M. Drabkin and H. Schulz-Baldes, Gaussian fluctuations of products of random matrices distributed close to the identity, J. Difference Equ. Appl., 21 (2015), 467-485.  doi: 10.1080/10236198.2015.1024672.  Google Scholar [10] S. Jitomirskaya, H. Schulz-Baldes and G. Stolz, Delocalization in random polymer models, Commun. Math. Phys., 233 (2003), 27-48.  doi: 10.1007/s00220-002-0757-5.  Google Scholar [11] M. Kappus and F. Wegner, Anomaly in the band centre of the one-dimensional Anderson model, Z. Phys., B 45 (1981), 15-21.  doi: 10.1007/BF01294272.  Google Scholar [12] J. M. Luck, Systèmes Désordonnés Unidimensionnels, Aléa, Saclay, 1992. Google Scholar [13] L. Pastur and A. Figotin, Spectra of Random and Almost-Periodic Operators, Springer, Berlin, 1992. https://www.springer.com/gp/book/9783642743481  Google Scholar [14] R. Römer and H. Schulz-Baldes, Weak disorder expansion for localization lengths of quasi-1D systems, Euro. Phys. Lett., 68 (2004), 247–253. https://iopscience.iop.org/article/10.1209/epl/i2004-10190-9 Google Scholar [15] C. Sadel and H. Schulz-Baldes, Scaling diagram for the localization length at a band edge, Ann. Henri Poincaré, 8 (2007), 1595-1621.  doi: 10.1007/s00023-007-0347-3.  Google Scholar [16] C. Sadel and B. Virág, A central limit theorem for products of random matrices and GOE statistics for the Anderson model on long boxes, Commun. Math. Phys., 343 (2016), 881-919.  doi: 10.1007/s00220-016-2600-4.  Google Scholar [17] R. Schrader, H. Schulz-Baldes and A. Sedrakyan, Perturbative test of single parameter scaling for $1D$ random media, Ann. Henri Poincare, 5 (2004), 1159-1180.  doi: 10.1007/s00023-004-0195-3.  Google Scholar [18] H. Schulz-Baldes, Perturbation theory for Lyapunov exponents of an Anderson model on a strip, Geom. Funct. Anal., 14 (2004), 1089-1117.  doi: 10.1007/s00039-004-0484-5.  Google Scholar [19] H. Schulz-Baldes, Lyapunov Exponents at Anomalies of $\rm SL (2, \mathbb{R})$-actions, Operator Theory, Analysis and Mathematical Physics, 174, 159–172. Birkhäuser, Basel, 2007. doi: 10.1007/978-3-7643-8135-6_10.  Google Scholar

show all references

##### References:
 [1] P. Bougerol and J. Lacroix, Products of Random Matrices with Applications to Schrödinger Operators, Birkhäuser, Boston, 1985. doi: 10.1007/978-1-4684-9172-2.  Google Scholar [2] Y. Benoist and J.-F. Quint, Random Walks on Reductive Groups, Springer, Cham, 2016. doi: 10.1007/978-3-319-47721-3.  Google Scholar [3] A. Bovier and A. Klein, Weak disorder expansion of the invariant measure for the one-dimensional Anderson model, J. Statist. Phys., 51 (1988), 501-517.  doi: 10.1007/BF01028469.  Google Scholar [4] R. Carmona and J. Lacroix, Spectral Theory of Random Schrödinger Operators, Birkhäuser, Basel, 1990. doi: 10.1007/978-1-4612-4488-2.  Google Scholar [5] B. Derrida and E. J. Gardner, Lyapunov exponent of the one dimensional Anderson model: Weak disorder expansion, J. Physique, 45 (1984), 1283-1295.  doi: 10.1051/jphys:019840045080128300.  Google Scholar [6] T.-C. Dinh, L. Kaufmann and H. Wu, Products of random matrices: A dynamical point of view, Pure and Applied Mathematics Quarterly, 2020, https://www.intlpress.com/site/pub/pages/journals/items/pamq/_home/acceptedpapers/index.php. Google Scholar [7] F. Dorsch and H. Schulz-Baldes, Random perturbations of hyperbolic dynamics, Electronic J. Prob., 24 (2019), 23 pp. doi: 10.1214/19-ejp340.  Google Scholar [8] F. Dorsch and H. Schulz-Baldes, Pseudo-gaps for random hopping models, J. Phys. A, 53 (2020), 185201, 21 pp. doi: 10.1088/1751-8121/ab5e8c.  Google Scholar [9] M. Drabkin and H. Schulz-Baldes, Gaussian fluctuations of products of random matrices distributed close to the identity, J. Difference Equ. Appl., 21 (2015), 467-485.  doi: 10.1080/10236198.2015.1024672.  Google Scholar [10] S. Jitomirskaya, H. Schulz-Baldes and G. Stolz, Delocalization in random polymer models, Commun. Math. Phys., 233 (2003), 27-48.  doi: 10.1007/s00220-002-0757-5.  Google Scholar [11] M. Kappus and F. Wegner, Anomaly in the band centre of the one-dimensional Anderson model, Z. Phys., B 45 (1981), 15-21.  doi: 10.1007/BF01294272.  Google Scholar [12] J. M. Luck, Systèmes Désordonnés Unidimensionnels, Aléa, Saclay, 1992. Google Scholar [13] L. Pastur and A. Figotin, Spectra of Random and Almost-Periodic Operators, Springer, Berlin, 1992. https://www.springer.com/gp/book/9783642743481  Google Scholar [14] R. Römer and H. Schulz-Baldes, Weak disorder expansion for localization lengths of quasi-1D systems, Euro. Phys. Lett., 68 (2004), 247–253. https://iopscience.iop.org/article/10.1209/epl/i2004-10190-9 Google Scholar [15] C. Sadel and H. Schulz-Baldes, Scaling diagram for the localization length at a band edge, Ann. Henri Poincaré, 8 (2007), 1595-1621.  doi: 10.1007/s00023-007-0347-3.  Google Scholar [16] C. Sadel and B. Virág, A central limit theorem for products of random matrices and GOE statistics for the Anderson model on long boxes, Commun. Math. Phys., 343 (2016), 881-919.  doi: 10.1007/s00220-016-2600-4.  Google Scholar [17] R. Schrader, H. Schulz-Baldes and A. Sedrakyan, Perturbative test of single parameter scaling for $1D$ random media, Ann. Henri Poincare, 5 (2004), 1159-1180.  doi: 10.1007/s00023-004-0195-3.  Google Scholar [18] H. Schulz-Baldes, Perturbation theory for Lyapunov exponents of an Anderson model on a strip, Geom. Funct. Anal., 14 (2004), 1089-1117.  doi: 10.1007/s00039-004-0484-5.  Google Scholar [19] H. Schulz-Baldes, Lyapunov Exponents at Anomalies of $\rm SL (2, \mathbb{R})$-actions, Operator Theory, Analysis and Mathematical Physics, 174, 159–172. Birkhäuser, Basel, 2007. doi: 10.1007/978-3-7643-8135-6_10.  Google Scholar
Plot of an orbit $(z_n)_{n = 1,\ldots,N}$ in $\mathbb{D}$ with $N = 5\cdot 10^3$ iterations of the random model described in Section 5. The parameters are $\epsilon = 10^{-4}$ and $\delta = 10^{-3}$ so that $\epsilon = o(\delta)$, and the initial condition is $z_0 = 1$. The random variable $\eta_{\sigma}\equiv -2$ is a constant. The histogram shows the distribution of the radii $|z_n|$. The tail of the distribution is merely due to the thermalization and does not occur if $z_0 = 0$
, but with the values $\epsilon = 0.1$ and $\delta = 10^{-3}$. For the plot on the left, $10^5$ iterations were run; for the histogram on the right, $5\cdot 10^5$ iterations were run. As in Figure 1, the initial condition is $z_0 = 1$. If the system starts with $z_0 = 0$, the plot and the histogram look very similar">Figure 2.  Same plot and histogram as in Figure 1, but with the values $\epsilon = 0.1$ and $\delta = 10^{-3}$. For the plot on the left, $10^5$ iterations were run; for the histogram on the right, $5\cdot 10^5$ iterations were run. As in Figure 1, the initial condition is $z_0 = 1$. If the system starts with $z_0 = 0$, the plot and the histogram look very similar
, but with the values $\epsilon = 0.1$ and $\delta = 10^{-5}$ so that $\delta = o(\epsilon^2)$. The number of iterations is $5\cdot 10^{4}$. The initial condition was $z_0 = 1$. If one chooses $z_0 = 0$ as initial condition, the orbit takes several hundreds of iterations to attain the boundary, but the histogram after a large number of iterations essentially looks the same">Figure 3.  Same plot and histogram as in Figure 1, but with the values $\epsilon = 0.1$ and $\delta = 10^{-5}$ so that $\delta = o(\epsilon^2)$. The number of iterations is $5\cdot 10^{4}$. The initial condition was $z_0 = 1$. If one chooses $z_0 = 0$ as initial condition, the orbit takes several hundreds of iterations to attain the boundary, but the histogram after a large number of iterations essentially looks the same
Approximate radial density $\varrho_{\lambda}$ (blue) given by (15) and numerical histogram of values of $|z_n|^2$ obtained after $2\cdot 10^7$ iterations (yellow). The values are $(\epsilon,\delta) = (0.05,7.5\cdot 10^{-4})$ on the left, $(\epsilon,\delta) = (0.05,1.2\cdot 10^{-4})$ in the middle, $(\epsilon,\delta) = (0.05,2.5\cdot 10^{-5})$ on the right
Numerical histograms of the distribution of $\frac{2}{\pi}\,\arctan(|z_n|^2)\in[0,1]$ after $2\cdot 10^7$ iterations (yellow) and suitably rescaled approximate radial density (blue) with $\mathcal{C}>0$ and $\mathcal{D}>0$ in violation of $\rm(v)$. The values are $(\epsilon,\delta) = (0.05,7.5\cdot 10^{-4})$ on the left and $(\epsilon,\delta) = (0.05,2.5\cdot 10^{-5})$ on the right. The model is described in detail in Section 5
, but with $\mathcal{C} = 0$ and $\mathcal{D}>0$. The values are $(\epsilon,\delta) = (0.05,5\cdot 10^{-4})$ on the left and $(\epsilon,\delta) = (2\cdot 10^{-4},0.05)$ on the right, further details are again found in Section 5">Figure 6.  Numerical histograms of the distribution of $\frac{2}{\pi}\,\arctan(|z_n|^2)\in [0,1]$ after $2\cdot 10^7$ iterations for the same model as in Figure 5, but with $\mathcal{C} = 0$ and $\mathcal{D}>0$. The values are $(\epsilon,\delta) = (0.05,5\cdot 10^{-4})$ on the left and $(\epsilon,\delta) = (2\cdot 10^{-4},0.05)$ on the right, further details are again found in Section 5
 [1] Rajeshwari Majumdar, Phanuel Mariano, Hugo Panzo, Lowen Peng, Anthony Sisti. Lyapunov exponent and variance in the CLT for products of random matrices related to random Fibonacci sequences. Discrete & Continuous Dynamical Systems - B, 2020, 25 (12) : 4779-4799. doi: 10.3934/dcdsb.2020126 [2] Janusz Mierczyński. Averaging in random systems of nonnegative matrices. Conference Publications, 2015, 2015 (special) : 835-840. doi: 10.3934/proc.2015.0835 [3] Doan Thai Son. On analyticity for Lyapunov exponents of generic bounded linear random dynamical systems. Discrete & Continuous Dynamical Systems - B, 2017, 22 (8) : 3113-3126. doi: 10.3934/dcdsb.2017166 [4] Pedro Duarte, Silvius Klein, Manuel Santos. A random cocycle with non Hölder Lyapunov exponent. Discrete & Continuous Dynamical Systems, 2019, 39 (8) : 4841-4861. doi: 10.3934/dcds.2019197 [5] Lianfa He, Hongwen Zheng, Yujun Zhu. Shadowing in random dynamical systems. Discrete & Continuous Dynamical Systems, 2005, 12 (2) : 355-362. doi: 10.3934/dcds.2005.12.355 [6] Philippe Marie, Jérôme Rousseau. Recurrence for random dynamical systems. Discrete & Continuous Dynamical Systems, 2011, 30 (1) : 1-16. doi: 10.3934/dcds.2011.30.1 [7] Janusz Mierczyński, Sylvia Novo, Rafael Obaya. Lyapunov exponents and Oseledets decomposition in random dynamical systems generated by systems of delay differential equations. Communications on Pure & Applied Analysis, 2020, 19 (4) : 2235-2255. doi: 10.3934/cpaa.2020098 [8] Yujun Zhu. Preimage entropy for random dynamical systems. Discrete & Continuous Dynamical Systems, 2007, 18 (4) : 829-851. doi: 10.3934/dcds.2007.18.829 [9] Ji Li, Kening Lu, Peter W. Bates. Invariant foliations for random dynamical systems. Discrete & Continuous Dynamical Systems, 2014, 34 (9) : 3639-3666. doi: 10.3934/dcds.2014.34.3639 [10] Weigu Li, Kening Lu. Takens theorem for random dynamical systems. Discrete & Continuous Dynamical Systems - B, 2016, 21 (9) : 3191-3207. doi: 10.3934/dcdsb.2016093 [11] Yong Chen, Hongjun Gao, María J. Garrido–Atienza, Björn Schmalfuss. Pathwise solutions of SPDEs driven by Hölder-continuous integrators with exponent larger than $1/2$ and random dynamical systems. Discrete & Continuous Dynamical Systems, 2014, 34 (1) : 79-98. doi: 10.3934/dcds.2014.34.79 [12] Petr Kůrka. Minimality in iterative systems of Möbius transformations. Conference Publications, 2011, 2011 (Special) : 903-912. doi: 10.3934/proc.2011.2011.903 [13] Petr Kůrka. Iterative systems of real Möbius transformations. Discrete & Continuous Dynamical Systems, 2009, 25 (2) : 567-574. doi: 10.3934/dcds.2009.25.567 [14] Björn Schmalfuss. Attractors for nonautonomous and random dynamical systems perturbed by impulses. Discrete & Continuous Dynamical Systems, 2003, 9 (3) : 727-744. doi: 10.3934/dcds.2003.9.727 [15] Ivan Werner. Equilibrium states and invariant measures for random dynamical systems. Discrete & Continuous Dynamical Systems, 2015, 35 (3) : 1285-1326. doi: 10.3934/dcds.2015.35.1285 [16] Weigu Li, Kening Lu. A Siegel theorem for dynamical systems under random perturbations. Discrete & Continuous Dynamical Systems - B, 2008, 9 (3&4, May) : 635-642. doi: 10.3934/dcdsb.2008.9.635 [17] Yuri Kifer. Computations in dynamical systems via random perturbations. Discrete & Continuous Dynamical Systems, 1997, 3 (4) : 457-476. doi: 10.3934/dcds.1997.3.457 [18] Thomas Bogenschütz, Achim Doebler. Large deviations in expanding random dynamical systems. Discrete & Continuous Dynamical Systems, 1999, 5 (4) : 805-812. doi: 10.3934/dcds.1999.5.805 [19] Shengtian Yang, Thomas Honold. Good random matrices over finite fields. Advances in Mathematics of Communications, 2012, 6 (2) : 203-227. doi: 10.3934/amc.2012.6.203 [20] Wen Huang, Zhiren Wang, Guohua Zhang. Möbius disjointness for topological models of ergodic systems with discrete spectrum. Journal of Modern Dynamics, 2019, 14: 277-290. doi: 10.3934/jmd.2019010

2019 Impact Factor: 1.27


text:
Home Reading Searching Subscribe Sponsors Statistics Posting Contact Spam Lists Links About Hosting Filtering Features Download Marketing Archives FAQ Blog From: Chris Kuklewicz list.mightyreason.com> Subject: Announcing Haskell protocol-buffers version 1.2.2 Newsgroups: gmane.comp.lang.haskell.libraries Date: Sunday 7th December 2008 21:17:04 UTC (over 8 years ago) Hi everyone, To keep up with protocol-buffers 2.0.3 here is an improved Haskell "hprotoc" version 1.2.2 : http://hackage.haskell.org/cgi-bin/hackage-scripts/package/protocol-buffers http://hackage.haskell.org/cgi-bin/hackage-scripts/package/protocol-buffers-descriptor http://hackage.haskell.org/cgi-bin/hackage-scripts/package/hprotoc The darcs repository with all 3 packages is at http://darcs.haskell.org/packages/protocol-buffers2/ These ought to be compatible with the previous version 1.2.1. As usual, this code read a ".proto" file which describes message formats and generates Haskell modes to encode and decode corresponding data type to the binary wire format. Google's original protocol buffers are at http://code.google.com/apis/protocolbuffers/docs/overview.html and generate code for C++, Python, and Java. Other languages are listed on the wiki at http://code.google.com/p/protobuf/wiki/OtherLanguages (including Haskell). The two changes are support for the field-option-like syntax for EnumValueOptions, and adjacent string literals are concatenated. Note that strings are checked for valid utf8 encoding after concatenation, not individually. But backslash escape codes are decoded for each individual string, not after concatenation. If these quirks become problems they can be changed. The protoc bug fixed in 2.0.3: > * Fixed bug where .proto files which use custom options but don't actually > define them (i.e. they import another .proto file defining the options) > had to explicitly import descriptor.proto." did not affect hprotoc, which already did the Right Thing™ (I just tested to be sure). The protoc bug fixed in 2.0.3: > * If an input file is a Windows absolute path (e.g. "C:\foo\bar.proto") and > the import path only contains "." (or contains "." but does not contain > the file), protoc incorrectly thought that the file was under ".", because > it thought that the path was relative (since it didn't start with a slash). > This has been fixed. is unlikely to be be present in hprotoc. But since I never run or test on Windows I make no promises hprotoc is finding the correct relative paths on Windows. Cheers, Chris Kuklewicz
CD: 3ms


text:
1 Reply Latest reply on Sep 24, 2008 8:17 AM by (scott_m_henderson)

Hi all

We're trying to deploy Adobe Reader 9 to 1800+ users but having trouble with the integration with our Document Management System (Interwoven) in that the users have to manually open, close then re-open Reader before integration works. We'd like to automate this if possible within the existing batch file. We've tried the following command lines:-

----------------------

:: Copy IManAcrobatReader.api to the local machine to re-enable Interwoven-integration

:: Update NRTDDE.INI to amend path to new Adobe Acrobat executable

----------------------

Adobe Reader 9 launches ok but will not close, the taskkill process does not appear to run for some reason.

Thanks
Scott
AutoIT worked a treat.

I used the following code:-

--------------------


text:
# If $p$ and $q$ are +ve real numbers such that $p^2+q^2=1$ then the maximum value of $(p+q)$ is

$(a)\;2\qquad(b)\;\large\frac{1}{2}\qquad$$(c)\;\large\frac{1}{\sqrt 2}\qquad$$(d)\;\sqrt 2$

Using AM $\geq$ GM


text:
# confontation

Fri Feb 13 13:07:03 PST 2009

i need greek letters for math work.

latex has the fonts of course, but i don't have the \mu \ro etc on
regular programs such as inkscape.
i've installed texcm-ttf, but only go a couple of greek letters.
mathfonts don't install and i'm really not sure that mathmatica fonts
are what i require anyway.

there doesn't seem to be a greek letters in ports.

any suggestions?

--
In friendship,


text:
# Definition:Convex Set (Order Theory)

## Definition

### Definition 1

A subset $A$ of an ordered set $\left({S, \preceq}\right)$ is convex (in $S$) if and only if:

$\forall x, y \in A: \forall z \in S: x \preceq z \preceq y \implies z \in A$

### Definition 2

A subset $A$ of an ordered set $\left({S, \preceq}\right)$ is convex (in $S$) if and only if:

$\forall x, y \in A: \forall z \in S: x \prec z \prec y \implies z \in A$

## Also see

• Results about convex sets can be found here.


text:
# How to set Import Units when importing a collada file with python script?

Blender shows the python command in the tooltip, for example, hover the mouse over File > Import > Collada (Default) (.dae), it shows:

Load a Collada file Python: bpy.ops.wm.collada_import()

Then I can find the bpy.ops.wm.collada_import() command in the script console.

I want to set the Import Units to True before I import the collada file, hover the mouse over the ticker it says

Python: WM_OT_collada_import.import_units

But I can't find any clue on how to use this piece of code.

WM_OT_collada_import is the bl_idname of the Collada Import Operator in the C-code notation (in Python it's wm.collada_import, but the importer is a C operator).
import_units is an operator property.
If you want to set this property to True in an operator call, give it a keyword-argument:
bpy.ops.wm.collada_import(filepath=..., import_units=True)


text:
# Question a3fcc

Feb 6, 2018

#### Answer:

The mass of $4.35 \times {10}^{25}$ ${N}_{2}$ molecules is $2024$ $g$.

#### Explanation:

Nitrogen atoms have a molar mass of $14$ $g m o {l}^{-} 1$.

The ${N}_{2}$ molecule has 2 atoms, so it has twice that mass, $28$ $g m o {l}^{-} 1$.

That means that one mole, Avogadro's number, $6.02 \times {10}^{3}$, of ${N}_{2}$ molecules would have a mass of $28$g.

To find our answer, then, we calculate:

$\frac{4.35 \times {10}^{25}}{6.02 \times {10}^{23}} \times 28 = 2024$ $g$