## Linear algebra: Do the non-symmetric matrices "defined strongly positive" have definite square roots that are unique and positive?

It is well known that if $$A$$ is a positive definite symmetric matrix, so it has a unique square root that is positive defined. My question is whether this result extends to a non-symmetric matrix defined strongly positive.

More precisely, let's go $$A$$ be a true non-symmetric $$n times n$$ matrix, which satisfies the following strong positive definite condition: there is $$a> 0$$ such that for each $$x en mathbb R ^ n$$, the estimate
$$langle Ax, x rangle geq a | x | ^ 2$$
Holds. Is it true then that there is a unique matrix? $$B$$ such that $$B ^ 2 = A$$? I would be very interested to know the answer to this result and to refer to a test. Thank you!

## Is there any uniformly continuous function of | R + a | R + (positive reals) such that f (n)> n ^ 2 for all n belonging to the set of naturals?

Was I trying to find an answer to the question of whether there is any uniformly continuous function in positive reals such that f (n)> n ^ 2 is valid for every natural n?

## Bar chart: Draw the bar graph horizontally for two groups using the positive x-axis in R

Given the following matrix

``````df <- matrix (c (10,8, 20, 6, 20, 25, "exp", "cnt", "exp", "cnt", "exp", "cnt", "gene1", "gene1" , "gene2", "gene2", "gene3", "gene3"),
nrow = 6, dimnames = list (c ("1", "2", "3", "4", "5", "6"), c ("Abundance", "Group", "gene")) )
``````

I would like to draw horizontally the bar graph for two groups "exp" and "cnt" separated by a vertical line at zero, the y axis shows positive values ​​corresponding to each gene and the name of the gene on the x axis.
Here is an example:

I tried the following code using ggplot but it did not work.

``````ggplot (df, aes (x = gene)) +
geom_bar (aes (y = Abundance, fill = "exp"), stat = "identity") +
geom_bar (aes (y = -Abundance, fill = "cnt"), stat = "identity") +
scale_fill_manual ("Group", values ​​= c (exp = "red", cnt = "green")) +
laboratories (y = "Abundance") + coord_flip ()
``````

Any suggestions?

## My review of Flipperhost after 2 months (extremely positive)

Ok, first of all, I'm usually cheap, I like to get a deal. I made the decision in 2018 to host my own mail server to gain some flexibility, save some money and have a new project. I chose, without knowing anything about the market, to go with the smoothing (which became AlphaRacks).

woothosting / AlphaRacks was just problems: slow servers, inactive servers, hours of delay for the response of the ticket, "update" randomly and change my IP (from a mail server without caring) until its eventual disappearance.

After a little research, Flipperhost was suggested, and I went with them; I needed my server to activate quickly. I've been with flipperhost for 2 months now.

The specifications in the Flipperhost server are:

System information
———–
Processor: Intel (R) Xeon (R) E5620 CPU at 2.40GHz
CPU cores: 4
Frequency: 2399,948 MHz
Memory: 4096 MB

I have 125 GB of storage and a 100 Mbps uplink.

I'm paying \$ 58.99 / year (google comeback4 for the promotion I used).

In the last two months I have been remarkably impressed. The VPS is doing everything I need to make an agile response from webmail pages, etc. The only problem I had was that my restore email to the new server since my backup was slower than I would like (100 Mbps port). I sent a ticket and they increased my speed.

I opened 4 tickets with them in two months: I needed RDNS to be on their side so my emails would not bounce, a faster transfer speed and I was blocked once due to something on their side. The response time of the ticket was less than one hour for resolution. I can not get that kind of response time in a corporate environment. I have dealt with "Steve D", "Brandon S" and "Kelly S". One of my tickets ended up being the result of a failure in the GoDaddy name server, not even the Flipperhost problem (and, nevertheless, they were useful to solve the problem).

I am so satisfied with the service that I bought another VPS with identical specification for my son / his friends to run a Unturned server (Steam game). My son is receiving more than 100 frames / second with the whole group in the game. He's excited, which gives me 'dad's points', so life is good.

My speedtest results are the following:

Speed ​​test (only IPv4)
———————

Location of speed provider
CDN Cachefly 85.4MB / s

Atlanta, GA, USA Coloat 36.7MB / s
Dallas, TX, US Softlayer 63.9MB / s
Seattle, WA, US Softlayer 73.8MB / s
San Jose, CA, US Softlayer 99.0MB / s
Washington, DC, US Softlayer 34.8MB / s

Tokyo, Japan Linode 19.2MB / s
Singapore Softlayer 12.1MB / s

Rotterdam, The Netherlands id3.net 7.67MB / s
Haarlem, The Netherlands Leaseweb 17.7MB / s

Disk speed
———-
I / O (first execution): 229 MB / s
I / O (2nd execution): 262 MB / s
I / O (3rd execution): 301 MB / s
Average I / O: 264 MB / s

In short, the only improvement would be the price (but I am quite happy with the price given the service). The machine works quickly, has no uptime problems and problem tickets have been fixed quickly and correctly. If only the rest of my world worked so well.

I would buy these guys again in the blink of an eye.

Andrew

## Was the set of expansions of eventually recurrent continuous fractions closed by multiplication by positive integers?

Is any result known about this? If so, are there simple resources or tests that show this?

## Specify that the argument of the function is positive.

Fighting with something basic. Suppose that by defining f[x_] the result depends on the signal[x]. When calling this function, how do I tell Mathematica the sign of the argument?
My intent:

``````F[x_]= x sign[x];
Assuming[a>0, f[a]]
``````

The output I get is

``````a signal[a]
``````

Obviously, I want to simply get `a` Because I'm trying to tell Mathematica. `a` is positive

## test and verification – Test if the function of multiple variables is positive or negative given constraints of variables

I have a function of multiple variables (5 to be exact). I would like to know if this function is positive or negative given certain restrictions in each of the 5 variables. Here is a simplified example:

F[a_,b_,c_,d_,e_] : = (2a-b + (c ^ 2) + d- (e * a)) / ((b + c-e) ^ 2)

It is positive or negative, given to> = 1, b> = 1, c> = 1,0 <= d <= 1,0 <= e <= 1

I know there is evidence as Positive, but I'm not sure how to add restrictions to those, since this is a mess of variables.

My example is relatively easy to do by hand, but the reality of my particular formula is much more complex. I feel that there is a way to do this and, in addition, that Mathematica tells me if there is a range of each variable value in which the function is positive or negative.

Thanks for any assistance you can offer!

## If m n, in lower terms, is the probability that a positive divisor chosen at random of 10 ^ 99 is an integral multiple of 10 ^ 88, then (m + n) is equal to t

I do not understand the question, can someone try to explain it in a non-abstract way?

Thank you

## computability: is it a language whose Turing Machine does not stop in some positive cases, but in others it is not recursive?

Say language $$L$$ is recursively enumerable, but not recursive.
Tell $$a$$ Y $$b$$ they are symbols of the alphabet and $$w$$ a word.
Let's say we have the following language:

$$L & # 39; = {aw | w in L } cup {bw | w notin L }$$

That is to say, $$L & # 39;$$ consists of the words that are in $$L$$ with a $$a$$ It is added to the beginning and words that are not in $$L$$ with a $$b$$ at first.

Is $$L & # 39;$$ not recursive? If we have the turing machine. $$TM$$ That decides $$L & # 39;$$, $$TM$$ will stop for some positive cases ($$w in L$$) but for other positive cases ($$w notin L$$) It will not stop. Is it therefore not recursively and recursively enumerable?

From what I understand:

• Recursively enumerable: the Turing machine will always stop if $$w in L$$Otherwise, it may or may not stop.

• Recursive It always stops.

• Recursively enumerable, but not recursive: it only stops if $$w in L$$; Otherwise, make a loop.

• Not recursively enumerable: there is no Turing machine.

So I do not know how to classify a language whose Turing Machine is stopped by some of its words.