plotting – Computing plane waves with the magnitude constant to 1

I have a question. In regards with the given computation,

u0(r_, phi_) := Sum(I^(-n) BesselJ(n, r) Exp(I n phi), {n, -5, 5});
{Plot3D(Re(u0(r, phi)), {r, 0, 4}, {phi, 0, 2 Pi}, 
  ColorFunction -> Hue), 
     Plot3D(Im(u0(r, phi)), {r, 0, 4}, {phi, 0, 2 Pi}, 
      ColorFunction -> Hue)}
{Plot3D(Abs(u0(r, phi)), {r, 0, 4}, {phi, 0, 2 Pi}, 
  ColorFunction -> Hue, PlotRange -> All), 
 Plot3D(Arg(u0(r, phi)), {r, 0, 4}, {phi, 0, 2 Pi}, 
  ColorFunction -> Hue, PlotRange -> All)}

which is in Cartesian coordinates, the magnitude of the series for the plane wave must be constant 1. How do I set this in the given code?


equation solving – Computing periodic points of some function

Instead of recursively determine the period points, you could first iterate the function and subsequently determine the period points.

E.g. let us define the n-iterated function fn({x_,y_}) for {b,c}=={1/100,-1} (note, it is better to use rational numbers if computing times allows):

hn({x_, y_}) = Nest(Simplify(h(#, 1/100, -1)) &, {x, y}, n)

E.g. for n=2 :

h2{x_, y_}) = Nest(Simplify(h(#, 0.01, -1)) &, {x, y}, 2)

enter image description here

This gives the following period points:

Solve(h2({x, y}) == {x, y}, {x, y})

enter image description here

Up to n==9 hn is calculated rather fast, but h10 suddenly takes much longer. The reason is not clear to me.

intervals – Computing possibles values (range) for an (polynomial) expression that takes values from two 2-simplex

Let $(p,q) in Delta_2$ and $(k,m) in Delta_2$, where
$Delta_2$ is the 2-simplex, that is,
$0leq pleq 1$, $0leq qleq 1$, and $0leq 1-p-qleq 1$.

Consider the expression

2 (p - q) + 3 k^2 (-1 + 2 p + q) + 
 k (1 + 6 (-1 + m) p + (3 - 6 m) q) - 
 m (1 + 3 p - 6 q + 3 m (-1 + p + 2 q))

I want to find the values that the expression above can take, given the
conditions on p, q, m, and k.

I tried an approach using Interval

expression(p_, q_, m_, k_) := 
 2 (p - q) + 3 k^2 (-1 + 2 p + q) + 
  k (1 + 6 (-1 + m) p + (3 - 6 m) q) - 
  m (1 + 3 p - 6 q + 3 m (-1 + p + 2 q))

and observing the values that it takes

substitute($p_, $k_) := 
 N((2 (p - q) + 3 k^2 (-1 + 2 p + q) + 
      k (1 + 6 (-1 + m) p + (3 - 6 m) q) - 
      m (1 + 3 p - 6 q + 3 m (-1 + p + 2 q)) /. {p -> $p, 
      k -> $k}) /. {q -> Interval({0, 1 - $p}), 
    m -> Interval({0, 1 - $k})})


Manipulate(substitute(p, q), {p, 0, 1, 1/10}, {q, 0, 1, 1/10})

However, using this values in the original expression, return lower values:

Table(expression(0, i, j, 0), {i, 0, 1, .1}, {j, 0, 1, .1}) // 
  Flatten // MinMax

at.algebraic topology – Adams blue book lemma 17.14: computing a $mathbb{F}_2$ basis for a filtration of $Hmathbb{Z}_*(bu wedge bu)$

First off let me apologize for not being able to give all the context for this question. I’m learning how to do computations in stable homotopy theory and have been particularly spending a lot of time trying to thoroughly understand the last two chapters of Adams blue book where he computes the cooperation algebra $bu_*bu$ of the 2-primary connective complex $K$-theory spectrum $bu$.

I’ve had a lot of trouble understanding one part of theorem 17.14 in the blue book. This theorem attempts to show that the $s$-line of the $E_2$ page of the Adams spectral sequence for $pi_*(bu wedge bu)$ maps is mapped injectively by the Hurewicz map into the quotient $F_s’ / F_{s + 1}’$ where $F_s’ = 2^s Hmathbb{Z}_*(bu wedge bu)$.

The particular part of Adams’ proof that I’m struggling with is the computation of a $mathbb{F}_2$ basis for the quotient $F_s’/F_{s + 1}’$. We know that a basis for the $E_2$ page of the AdSS for $pi(bu wedge bu)$ is given by elements of the form $xi^{m_i}eta^{n_i}g_i$ for all $i in mathbb{N}$ where $xi in Ext^{1, 1}_{E(1)}(mathbb{F}_2, mathbb{F}_2)$ and $eta in Ext^{1, 3}_{E(1)}(mathbb{F}_2, mathbb{F}_2)$ and each $g_i$ is a generator of $mathbb{F}_2(xi, eta)$.

Adams starts by taking an element $xi^{b_i}g_i$ which sits on the $0$-line and in a $xi$ tower above $g_i$. He takes a representative $gamma_i in pi_*(bu wedge bu)$ of the class $xi^{b_i}g_i$ and then considers the image under the mod $2$ Hurewicz map:

h_{mathbb{F}_2}(gamma_i) = 1 otimes h_i + cdots in {Hmathbb{F}_2}_*(bu wedge bu).

The form of $h_{mathbb{F}_2}(gamma_i)$ here is given by the Kunneth theorem and the definition of graded tensor product. We omit most of the summands here since they’re not important.

So now we’re at the point where I’m confused. Adams states that “by construction” the element $h_i$ above corresponds to the element $zeta_1^{2i}$ of ${Hmathbb{F}_2}_*(bu)$. This element $zeta_1^{2i}$ is the $i$‘th basis element of the $beta_2$ Margolis homology of ${Hmathbb{F}_2}_*(bu) cong mathbb{F}_2(zeta_1^2, zeta_2^2, zeta_3, zeta_4, …)$ where $beta_2$ is the Bockstein.

So my question is essentially why does $h_i = zeta_1^{2i}$ hold and why is this by construction?

Note that in the original proof Adams is focused on a more general cooperation algebra $pi_*(bu wedge X)$ instead of $pi_*(bu wedge bu)$, but I only care about the case of $X = bu$ right now so that’s how I presented Adams work above even though he’s treating a more general case.

I apologize in advanced for the length of the question, typos and mistakes, and lack of etiquette! This is my first time posting. I’m hoping some people with more experience with this book than me can set me on the right track!

parallel computing – Repeatedly finding and deleting maximal independent sets on a graph: Number of necessary iterations in restricted cases

I am trying to design a parallel scheduling algorithm based on a constraint graph $G=(V,E)$ in which each node represents a task and each edge $e=(v_1, v_2)$ signifies, that tasks $v_1$ and $v_2$ can not be executed in parallel. Each task is executed exactly once, so the problem is finding “good” independent sets $V_i$, so that

bigcup_{i=1}^{k} V_i = V\

with all independent sets $V_i, V_j$ being pairwise disjoint. Since MaxIS is NP-Hard my approach would be solving MIS repeatedly (finding some maximal independent set, removing those vertices and start again until the Graph is empty). I know that in the worst case of $G$ being a clique this approach would yield $n$ iterations, however in my instance i would have the guarantee that the number of neighbors of each node would be upper-bound by $c ll |V|$.

My question is: Given such a $c$ is there any upper bound on the number of necessary steps $k$?

Algorithm Design Problem Challenge, Arrays of different length and computing the lead_time of jobs

I need some help in getting the average lead_time for the remaining jobs. Let’s suppose a1,a2,a3…..,an is the starting time of the jobs in ascending order, and b1,b2,b3,…..,bn are the ending times of the jobs in random order. Let’s suppose files (containing jobs) are transferred from one desk1 to desk2 and some of the jobs will complete before the transfer time and a lead_time will be established for the remaining jobs that were started at desk1. t1,t2,t3….,tm (ascending order) are the file transfer time from desk1 to desk2. Suppose tm>an and the file never visits the already visited desk.

My approach to solve this problem is as follows, I have checked if the job is ongoing at transfer time by taking the difference of job completion time and transfer time: pseudo code

    start_time = {a1, a2, a3,....,an} // (ascending order)
    end_time = {b1, b2, b3,....,bn} // (random order) (jobs can be or random duration)
    transfer_time = {t1,t2,t3,....,tm} // (ascending order)
    lead_time = 0
    jobs_desk2 = 0 
    for (int i = 0; i<m; i++){ 
        if(t(i) > a(i) && b(i) > t(i) && t(i) != 0){
            lead_time += b(i) - t(i)
    lead_time = lead_time/jobs_desk2

algorithms – Computing common tangent between two convex polygon

Given two convex polygons that each have size $O(n)$, we want to find
common upper tangent between given convex polygons.

I think consider right most vertex hull $q$ of left most polygon, and left most vertex hull $p$ of right most polygon, find tangent of $q$ to right most polygon in $O(log n)$,and chosen vertex $t$ from right most polygon , we have a line tangent from $q$ to $t$, then find tangent of $t$ to left most polygon in $O(log n)$ , but at this step my problem are, first, are my idea is true? and how binary search must work to find said tangent from a point to polygon?. I read many resources, but i cant find an precise description how it work.

front end – small web frontend for c++ computing app (webapp beginner)

I am a newbie with JS (I’ve done some small webapps with pure python or c++; I have otherwise strong background in numerics, both c++ and python, and Linux system administration and networking) and would like to take the next step using useful current technologies.

I have a computing backend (in c++) and need to create a simple webpage which will show some plots with data streaming from the backend and a simple form displaying and allowing to set some parameters for the backend (about a dozen, mostly floats). The app does not need to be hard-realtime (update twice a second is okay), it will be used over LAN only. The visual is completely irrelevant, someone can do some CSS later. There will be also a link or two for file download (quite normal over HTTP, presumably).

What would be the suggested approach? I was thinking of exposing the data over HTTP endpoints (like a simple REST API), then JS-side consuming the data. What technology to use for the frontend (I look at Vue briefly)? How to get updates from the server? Polling the API (as it is LAN, that would be okay for me, but is not elegant)? Pushing data through a websocket? Or ditching any HTTP access and run everything through the socket?

I will be glad for some pointers. There are many posts about how to do this or that but I cannot tell short-lived hype from useful evolutions.


operating systems – Computing the number of Cylinder

For magnetic disks, there is a direct adressing scheme made of:

  • head (platter side),
  • cylinder (track number, independently of the platter) and
  • sector

It’s all well explained here on wikipedia. 20 tracks, means 20 cylinders. No more calculation. Combined with 200 heads (100 platter*2 sides) and 50 sectors, that’s 200 000 addressable blocks (sometimes ambiguously called sector)

For magnetic tapes, there are at most 2 heads, no cylinder, but a sequential structure of blocks that are similar to sectors in that they decompose the storage media into smaller pieces. There is by the way no direct access.

In consequence, the question is a trap: there are no cylinders on a tape.

discrete mathematics – Computing conway chained arrow notation

I don’t understand how to implement a class that can store a number in this notation and convert it to a regular number: Here’s what I have so far (ommited some code)

#Computes a -> b -> c ... with(a, b, c, ...) as args
class conway():
    def __init__(self, *args):
        self.seq = args
    def toNumber(self, _ = 0):
        x = self.seq(_)
        n = 1
        if _ == len(self.seq) - 1: return x
        for i in range(self.toNumber(_ + 1)):
            n *= x
        return n

I understand that my code so far computes arrow notation instead of chain notation (a ** b ** c ** ...) which can be computed much more easily, but I don’t understand how you would achieve chain. Conway chained arrow notation