## Complex analysis: show that the Möbius transformation assigns each straight line to a line or circle, and assigns each circle to a line or circle

I found this statement on wiki:

These transformations preserve angles, map each straight line to a line or circle, and map each circle to a line or circle.

Speaking of the Möbius transformation, I found proof of the invariability of the angles, but nothing else. Does anyone know how we can prove it?

## probability: derives the distribution t using the transformation of random variables.

They ask me to derive the pdf from the distribution t as follows.

$$V = frac {Z} { sqrt {U / n}}$$ where $$Z$$ it is the normal standard and $$U$$ it is the chi-square distribution with degree of freedom n.

Leaving $$Y = sqrt {U / n}$$, we can find the pdf of $$Y$$ be

$$F_Y (y) = P ( sqrt {U / n} leq y) = P (U / n leq y ^ 2) = P (U leq ny ^ 2) = F_U (ny ^ 2)$$
$$f_Y (y) = 2yn f_U (ny ^ 2)$$

And then, using the formula to find the pdf of the proportion of random variables, we get

$$f_V (v) = int ^ { infty} _ {0} f_Z (vy) f_Y (y) dy$$

But I can't get the right answer trying to integrate the previous integral.

Am I right up to this point?

Thanks for your help.

## integration – What is the Fourier transformation of \$ f_t (x) = e ^ {- x ^ 2 / t ^ 2} e ^ {- ix ^ 2 / 2t} \$?

Pin up $$t> o.$$ Define $$f_t (x) = e ^ {- x ^ 2 / t ^ 2} e ^ {- ix ^ 2 / 2t} (x in mathbb R).$$ I would be interested in calculating the Fourier transform of $$f_t$$ and then it is $$L ^ 1 standard.$$ Specifically, my questions are:

(1) Can we know what it is $$widehat {f_t} ( xi) = int _ { mathbb R} e ^ {- x ^ 2 / t ^ 2} e ^ {- ix ^ 2 / 2t} e ^ {- 2 pi x xi} dx$$?

(2) If so, what is the behavior of $$lim_ {t a 0} frac {1} {t} int _ { mathbb R} | widehat {f_t} ( xi) | d xi$$? (I mean: is it finite or infinite?)

## How to calculate the inverse transformation of this function?

I don't know how to calculate the inverse transformation of this function:
$$z = L ^ -1 {-3s ^ 3 / (3s ^ 3 + 16s ^ 2 + 16}$$

The solution is:

$$z = cos (2t / sqrt (3)) / 2 – 3/2 cos (2t)$$

## Photo editing: What is the name of this image (or video) transformation?

It is very common today, especially with videos and photos of smartphones. It consists of adding the same enlarged image in the background, to convert a portrait image into a landscape image, as seen below. I'm sure it's super obvious, but I searched it on Google without success.

## transformation – Nested transform.position in Unity

The following code works so good, but it is so long.

How can I use a `for` loop to write a short script for any number of prefabs?

``````public GameObject prefab1;
public GameObject prefab2;
public GameObject prefab3;
float timCounter = 0f;

void FixedUpdate()
{
timCounter += Time.deltaTime;

float()  r = {3,2,1};
float()  f = {3,2,1};

//motion on a circle

float x = r(0) * Mathf.Cos(f(0) * timCounter);
float y = r(0) * Mathf.Sin(f(0) * timCounter);

float x1 = r(1) * Mathf.Cos(f(1) * timCounter);
float y1 = r(1) * Mathf.Sin(f(1) * timCounter);

float x2 = r(2) * Mathf.Cos(f(2) * timCounter);
float y2 = r(2) * Mathf.Sin(f(2) * timCounter);

float z = 0;

//position of a any prefab_n = position of prefab_(n-1) + Vector3(x,y,z)

prefab1.transform.position = new Vector3(x,y,z);

prefab2.transform.position = prefab1.transform.position + new
Vector3(x1,y1,z);

prefab3.transform.position = prefab2.transform.position + new
Vector3(x2,y2,z);
}
``````

## number theory: Fourier transformation of f (x)

Leave $$x in V$$ , where $$V$$ it's a real vector space and $$dim$$ $$V = n$$ . The Fourier Transform
is defined as $$hat f (y) = int_ {x in V} f (x) e ^ {2 pi ixy} dx.$$

1) for $$f (x) = e ^ {- pi x ^ 2}$$ I have $$hat {e ^ {- pi y ^ 2}} = int_ {x in V} e ^ {- pi x ^ 2} e ^ {2 pi i xy} dx = e ^ {- pi y ^ 2} int_ {x in V} e ^ {- pi (x-iy) ^ 2} dx = e ^ {- pi y ^ 2}.$$

2) for $$a> 0$$ and $$f (ax)$$ I have $$hat {f} (ay) = int_ {x in V} f (ax) e ^ {2 pi ixy} dx.$$ Set $$z = ax$$ , $$dz = a ^ ndx$$ then

$$hat {f} (ay) = int_ {z in V} f (z) e ^ {2 pi i frac {z} {a } y} a ^ {- n} dz = hat {f} (y / a) a ^ – n}.$$
It is right ?

Thanks for the help .

## unit: object transformation rotation around the correct pivot, but an incorrect pivot after colliding

I'm playing a little trying to create a table football table. So, this involves creating bars with players in them. The bar must be able to rotate freely around the Z axis with the players moving around the Z axis of the bars. I created a parent object for the bar with players to make any transformation. I made sure that the pivot point is in the center of the bar so that when turning along the Z axis of the game object it keeps the bar in position while turning. This worked as shown in the first image, the position of the object remains unchanged while rotating.

The problem arises when I run the game and make a ball collide with the & # 39; player & # 39 ;, this causes the player and the bar to spin, but not around the right pivot point. The bar now moves in a circular / elliptical pattern. I verified that the rotation is not happening around the center point either and it is not. It rotates around an axis somewhere between the center point and the pivot point. Am I doing something wrong or am I addressing this from a completely wrong angle?

## Functional analysis of fa – Coverage number of \$ c \$ – Transformation of a collection of functions

I am trying to understand the concepts of coverage and packaging of the collection of functions in a metric space. Thanks in advance for any contribution.

Leave $$mathcal H$$ be a collection of functions $$mathcal X rightarrow (0, M)$$, in a metric space $$mathcal X = ( mathcal X, d)$$. by $$h in mathcal H$$ and $$lambda ge 0$$, define $$h_ lambda: mathcal X rightarrow mathbb R$$ by $$h_ lambda (x): = sup_ {x & # 39; in mathcal X} h (x & # 39;) – lambda d (x & # 39 ;, x)$$. Leave $$L> 0$$ and define the collection derived from functions $$mathcal H_L: = {h _ { lambda} mid h in mathcal H, ; lambda in (0, L) }$$. I am interested in complexity measures. For example, I would like to estimate the coverage number of $$mathcal H_L$$that is to say

$$mathcal N_p ( mathcal H_L, varepsilon, n): = sup_ {x_1, ldots, x_n in mathcal X ^ n} mathcal N_ {n, p} ( mathcal H_L (x_1, ldots, x_n), varepsilon),$$
where $$mathcal H_L (x_1, ldots, x_n): = {(h_ lambda (x_1), ldots, h_ lambda (x_n) mid h in mathcal H } subseteq mathbb R ^ n$$ and $$mathcal N_ {n, p} (A, varepsilon)$$ is the minimum number of radio balls $$varepsilon$$ need to cover a subset $$A$$ of metric space $$( mathbb R ^ n, ell_p)$$.

Now, it's easy to see that, every $$h _ { lambda} in mathcal H_ lambda$$ is $$lambda$$-Lipschitz, because

$$begin {split} | h _ { lambda} (x) -h _ { lambda} (x_0) | &: = | sup_ {x & # 39;} h (x & # 39;) – lambda d (x & # 39 ;, x) – sup_ {x & # 39;} h (x & # 39;) – lambda d (x & # 39 ;, x_0) | \ & le sup_ {x & # 39;} | h (x & # 39;) – lambda d (x & # 39 ;, x) – (h (x & # 39;) – lambda d (x & # 39 ;, x_0)) | \ & = lambda sup_ {x & # 39;} | d (x & # 39 ;, x) -d (x & # 39 ;, x_0) | le lambda d (x, x_0) end {split}$$
A) Yes $$mathcal H_L subseteq text {BLip} _ {M, L} ( mathcal X rightarrow mathbb R)$$, where
$$text {Lip} _ {M, L} ( mathcal X rightarrow mathbb R): = {h: mathcal X rightarrow (0, M) mid f text {is} L text {- Lipschitz continued} }.$$
It follows then (for example) that

$$mathcal N_ infty ( mathcal H_L, varepsilon, n) le mathcal N_ infty ( text {BLip} _ {M, L} ( mathcal X rightarrow mathbb R), varepsilon, n) le mathcal N_ {n, p} ((0, M), varepsilon / L) = (LM / varepsilon) ^ n.$$

• Is my previous reasoning correct?
• I am intrigued by the fact that the previous limit is independent of the complexity of $$mathcal H$$ or the "dimension" of $$mathcal X$$. I'm missing something.

## image – Hough transformation algorithm – Idiomatic c ++

I have a work code to calculate the Hough transformation for circles:

``````
#include
#include
#include
#include
#include

int *** allocate3DArray(int y, int x, int r)  {
int ***array = (int***)malloc(sizeof(int**)*y);
for (int i = 0; i < y; i++)  {
array(i) = (int**)malloc(sizeof(int*)*x);
for (int j = 0; j < x; j++)  {
array(i)(j) = (int*)malloc(sizeof(int)*r);
for(int k = 0; k < r; k++) {
array(i)(j)(k) = 0;
}
}
}
return array;

}

void free3d(int ***arr, int y, int x, int r)  {
for (int i = 0; i < y; i++)  {
for (int j = 0; j < x; j++)  {
free(arr(i)(j));
}
free(arr(i));

}
free(arr);

}

vector HoughTransformCircles(Mat image, Mat &gradient_mag, Mat &gradient_dir)  {
//Maximum circle radius is rLen = image.width / 2
int rLen = image.rows/2;
int ***houghSpace = allocate3DArray(image.rows, image.cols, rLen);
for (int y = 0; y < image.rows; y++) {
for (int x = 0; x < image.cols; x++) {
for (int r = 0; r < rLen; r++)     {
int x0 = x - (int)(r*cos(gradient_dir.at(y, x)));
int y0 = y - (int)(r*sin(gradient_dir.at(y, x)));
if(x0 >= 0 && x0 < image.cols && y0 >= 0 && y0 < image.rows )  {
houghSpace(y0)(x0)(r)++;
}
x0 = x + (int)(r*cos(gradient_dir.at(y, x)));
y0 = y + (int)(r*sin(gradient_dir.at(y, x)));
if(x0 >= 0 && x0 < image.cols && y0 >= 0 && y0 < image.rows )  {
houghSpace(y0)(x0)(r)++;
}

}
}
}
vector circles;
for (int y = 0; y < image.rows; y++)    {
for (int x = 0; x < image.cols; x++)  {
for (int r = 0; r < rLen; r++)  {
if (houghSpace(y)(x)(r) > 30)  {
Circle temp  = Circle(x, y, r);
circles.push_back(temp);
}
}
}
}

free3d(houghSpace, image.rows, image.cols, rLen);

return circles;
}

``````

How do I make this as idiomatic as possible? I am not allowed to use C ++ 11 unfortunately.