## macbook pro – kernel_task eating 1000% of my CPU regardless of the CPU being at 56-58 degrees

I’m currently struggling with kernel task on my 1 year old Macbook Pro 16″ 2019.
Basically I’m currently using an external monitor which is connected to my macbook via a usbc to displayport cable which is connected to the right side of my macbook along side with the DC cable. On the left side I only have a dongle which I use to connect my mouse to my macbook.

Here are a couple of pictures showing my temperatures. I’d like to highlight the fact that I’m not running ANY task on my macbook. I just connected the external monitor.

What I did so far in order to try to mitigate the issue:

• Resetting the SMC
• According to some people, kernel_task is triggered by “thunderbolt left proximity” temperature, but it doesnt seem to be my case. I tried completely disconnecting the dongle, the temperature reaches ~38 degrees, yet the issue persists
• Completely wiped my mac to make sure the issue wasnt one of the softwares I had installed, but the issue persists even with almost no programs running in the background
• Tried different monitors and cables. I tried using HDMI cables and my old BENQ monitor and my television, the issue still persists.
• I tried using my macbook in clamshell mode and I bought a vertical laptop stand because according to some people it helps dissipating heat, but of course it wont work.

I know kernel_task is supposed to make the CPU less available to those processes which are causing the macbook to overheat, but why is it taking so much CPU when there’s literally no user processes using the CPU and the macbook is not even hot?

What form field labels tend to be used for pre-nominal and post-nominal academic titles in forms? Is e.g. "prenominal academic degree" used or is that too formal?

## 3d – Calculate how many degrees each side of the device is up or down

There is a physical device (sensor) which I can rotate. The device sends its X Y Z coordinates and a calculated acceleration vector in mg (mill mg). I can read this data from this device by using BLE. The device should lie flat while transportation, so I need to calculate how many degrees each side of the device is up or down.

Let me illustrate:

So, what I need to find out is how many degrees the device’s central vector (I guess?) is off the X Y Z axis?

Any help is greatly appreciated. Please, let me know if I should update my answer or give more details.

## video – Camera for use in Submerged Water tank Operating at 90 Degrees Centigrade

video – Camera for use in Submerged Water tank Operating at 90 Degrees Centigrade – Photography Stack Exchange

## unity – How can I rotate the player only to -40 or -45 degrees?

``````float c = 0.0f;
private void FixedUpdate()
{
if (startRotatingBack)
{
var p = transform.eulerAngles;

if (p.y != -40)
{
p.y -= 1;
transform.eulerAngles = p;
}

c = c + 0.1f;
playerAnimator.SetFloat("Forward", c);
}
}
``````

The problem is that the transform keeps rotating nonstop.

Maybe the problem is with this chick?

``````if (p.y != -40)
``````

I want to make that the player will rotate backward. -40 or -45 is good enough but the player the transform is keep rotating nonstop so it’s making circles instead of rotating once to -40 or to -45.

I tried also this way but it’s not working either :

``````if (!Mathf.Approximately(p.y, -40))
``````

## unity – How can I rotate the camera 360 degrees around but also to rotate the camera around the player?

``````private void Start()
{
offset = new Vector3(player.position.x, player.position.y, player.position.z);
}
``````

And in the Update

``````private void Update()
{
if (orbitCamera)
{
transform.eulerAngles += rotationSpeed * new Vector3(-Input.GetAxis("Mouse Y"), Input.GetAxis("Mouse X"), 0);

offset = Quaternion.AngleAxis(Input.GetAxis("Mouse X") * rotationSpeed, Vector3.up) * offset;
transform.position = player.position + offset;
transform.LookAt(player.position);
}
}
``````

There are two problems :

When the part that rotate the camera around the player is working this lines :

``````offset = Quaternion.AngleAxis(Input.GetAxis("Mouse X") * rotationSpeed, Vector3.up) * offset;
transform.position = player.position + offset;
transform.LookAt(player.position);
``````

It’s making the camera move far very far from the player and also I can rotate it around the player but only on the X the first part line :

``````transform.eulerAngles += rotationSpeed * new Vector3(-Input.GetAxis("Mouse Y"), Input.GetAxis("Mouse X"), 0);
``````

If it was only with this line then I could rotate the camera around up and down and in all directions but now I can only rotate it around the player and only on the x.

I want that it will not change the camera position and to be able to rotate around and the player and also up and down all around.

## lo.logic – 2-REA PA degrees

Remember that an n-REA set is a set of the form $$A_0 oplus A_1 oplus ldots A_n$$ with $$A_n$$ relatively r.e. in $$A_m, m (so $$A_0$$ is r.e.) and that a degree is PA just if it computes a path through every infinite computable tree.

By Arslanov’s completeness criterion no incomplete r.e. set can be of PA degree. While pursuing another problem I’m pretty sure I constructed a low 2-REA set of PA degree but before I bother to include that writeup in some paper (it’s not the most riveting proof but seems worth mentioning somewhere) or even spend a bunch of time double checking it I wanted to see if it’s known.

So anyone know if this result (or refutation) is already in the literature or is trivial to derive from it (e.g., clever use of relativized jump inversion)?

## factorization – Can Mathematica factor multivariate polynomials with 4 or more variables? And with high degrees (>10)

The Mathematica documentation clearly states

the Wolfram Language routinely factors degree-100 polynomials in 3 variables

I’m interested in factoring systems of polynomials in as many as 10 or 20 variables. The systems I have are sparse in the sense that if there are 20 variables then likely no more than 3-6 variables will appear per equation and there will likely only be two terms per equation. I’ve used `Solve` to test on some small systems with success. To be clear, we don’t actually need to factor the polynomials necessarily. If we factor them, then we have what we need. What we really want are the roots to the system with respect to the symbolic coefficients. `Solve` worked for some small test systems. `Factor` would also work for a single polynomial, but we need a system of polynomials and I don’t see that `Factor` will take a system.

I’ve looked at papers by searching scholar.google.com and it seems our problem is a solved problem in mathematics. Algorithms seem to exist for such a problem, but I’m even unclear on this since the papers are too densely packed with math for me to easily understand.

Any help would be appreciated.

## combinatorics – How many graphs are there on 4 nodes with degrees 1, 1, 2, 2?

I know just the basic operations on graphs using Mathematica. But I want to know how to write a code that prints all the possible combinations of a graph with a specified number of edges.

Take for example:

How many graphs are there on 4 nodes with degrees 1, 1, 2, 2?

I know the answer mathematically is 12, but I want Mathematica to print these combinations.

## algorithms – Random graphs with prescibed degrees and triangles

Consider two sequences of $$n$$ integers $$a_i$$ and $$b_i$$, for $$i$$ from $$1$$ to $$n$$, and build a (multi-)graph with vertices $$1$$ to $$n$$ using the following extension of the configuration model: attach to vertex $$i$$ exactly $$a_i$$ stubs, called edge stubs, and $$2cdot b_i$$ stubs, called triangle stubs; then, take random pairs of edge stubs to form edges and random triplets of pairs of triangle stubs to form triangles.

I have several questions:

• what are the conditions on the two sequences that ensure that a simple graph (no loop, no multi-edge) can be obtained?
• is there a procedure to build such a simple graph, if it exists?
• how to compute the expected number of triangles in the graph? and the number of triangles involving each vertex?
• is there a procedure that builds such a graph with the additional constraint that vertex $$i$$ belongs to exactly $$b_i$$ triangles?

An extension of the Erdös-Gallai criterion would anser the first question. An extention of Havel-Hakimi algorithm would answer the two first questions.

For the two last questions, please note that some triangle may appear due to edge stub pairings, but also that triangle stubs “pairing” may lead to additional triangles, and combinations of edge and triangle stubs may also lead to additional triangles.

Are answers to these questions known in the literature?

This model was proposed in the paper Random graphs with clustering by M. E. J. Newman, but studied only within mean field approximation, if I am correct.