plotting – How to efficiently animate changing mesh on a fixed 3D plot?

Say I’d like to visualise a height function of a torus by animating a plane going upwards, and highlighting the intersection via `Mesh`/`MeshFunctions`. I draw the torus using `ParametricPlot3D`, and I would like it to be very smooth and nice looking, so I put somewhat high values of `PlotPoints` and/or `MaxRecursion`. I produce an animation using `Table` with the parameter being the value in `Mesh`.

Now the problem is, that each frame of my animation recomputes the torus, which takes a lot of time. Is there a way to only compute the torus once, and then just compute different meshes for each frame? Maybe I could compute all the meshes while computing the plot, and then just display one at the time? Can I extract meshes as, say, `GraphicsComplex` and combine it back with the plot in `Show`?

complexity theory – What about problems that are fixed parameter tractable with an algorithm that does not inspects the parameter

A parameterized problem is a subset $$L subseteq Sigma^* times mathbb N$$, where $$Sigma$$ is a finite alphabet. A parameterized problem is fixed parameter tractable, if it could be decided in time $$f(k)|x|^{O(1)}$$ for some $$(x,k) in L$$.

In terms of the problem definition, a Turing machine for $$L$$ has access to the parameter. I noted that for some algorithms, for example the kernelization of vertex cover, the algorithm indeed must have access to it, whereas for others, for example clique paramterized by maximal degree, it does not need access to the parameter. The algorithm for the latter simply looks into the neighbourhood of every vertex if it contains a clique, hence it runs in time $$O(2^{Delta} |x|)$$, where $$(x, Delta) in L$$.

Was this ever noted? And if so, is there some notion like FPT without access to the parameter, i.e., a problem $$Lsubseteq Sigma^*$$ is in “FPT without access to the parameter”, if it runs in time $$f(k)|x|^{O(1)}$$ for $$x in L$$ and some number $$k$$ that depends on $$x$$ (I avoid the term parameter, as it is not given as input)? Or would it not make sense to consider such a class?

Exchange Btc, Eth, Bsv, Usdt, Xrp And More Within 15 Min With Fixed & Float Rates. All Languages Supported.

Who we are?
ChangeHero is an instant cryptocurrency exchange started by a team of crypto experts in 2018. ChangeHero rose to popularity due to its commitment to deliver the best user experience and customer service and the excellent rating on Trust Pilot reflects it.

What do we offer?

• Exchange Bitcoin, Ethereum, Bitcoin Cash, Tether, XRP, Bitcoin SV, Litecoin and many other cryptocurrencies instantly
• Buy Bitcoin with credit and debit card
• Sell Bitcoin for USD and Euro

Features:

• No registration or account needed to exchange crypto
• ChangeHero is a non-custodial service, we neither hold nor store your crypto
• Exchange crypto with both Best rate and Fixed rate.
• Earn up to 50% of revenue through referrals

You can be sure that will get the best rates in the market for all your transactions. ChangeHero follows the customer-first policy and strives the deliver the best service to all our customers. Do visit ChangeHero and swap cryptocurrency like a pro.

What customers are saying about us?
Trustpilot – https://www.trustpilot.com/review/changehero.io
BestChange – https://www.bestchange.com/changehero-exchanger.html

How to reach us?
Changehero – Official website
Email – (email protected)
Reddit – https://www.reddit.com/r/ChangeHero/
Telegram – https://t.me/joinchat/NtTByBZ0aAhtsAN3ZvV0lw

dynamic – How to plot the stable and unstable manifolds of a hyperbolic fixed point of a nonlinear system of a map?

I would like to plot the stable and unstable manifold of the Hénon map x_{n+1} = 1 – a*x_n^2 + by_n, y_{n+1} = x_n. I believe that iterate the inverse map i would get the stable curve, and for the unstable i need to choose an large number of initial conditions inside the neighborhood of the saddle point along the unstable direction and then iterate the map for a few times, but i do not know how to do this things.

opengl – How do I render to a resizable window from a large fixed size back buffer in current graphics APIs?

I have some code that uses DirectX 9 with Windows native window management, that I would like to port to newer graphics APIs, but this code has a fairly unusual approach to window resizing, and it doesn’t seem obvious how to achieve the same things with newer graphics APIs.

The code I want to port allocates a back buffer large enough for a full screen window which remains the same size across window maximised, minimised, and resize events. When the window is smaller than the back buffer, only part of the back buffer is shown.

In order to render from this large back buffer, in DirectX 9, I’m specifying regions with the pSourceRect and pDestRect in IDirect3DDevice9::Present and using D3DSWAPEFFECT_COPY.

The advantages of this, as I see it, are as follows:

• There’s no need to free and reallocate any resources in response to window size changes.
• Not reallocating resources reduces code complexity significantly.
• Not reallocating resources makes the application more responsive in the case of windows size changes.
• The rendered scene continues to be drawn, smoothly, as the application window is being resized, without any need for potentially tricky and complicated attempts to update rendering settings in response to resize events.

(As the code is written, the application is essentially paused during window resize. The user nevertheless gets a smoothly updated view of the relevant part of the current static rendered scene during window resize.)

How do I do the same thing with newer graphics APIs?

In newer DirectX versions it seems like the ‘BitBlt model’ described on this page roughly corresponds to D3DSWAPEFFECT_COPY in DirectX 9:
https://docs.microsoft.com/en-us/windows/win32/direct3ddxgi/dxgi-flip-model

However, when I try setting the swap effect to DXGI_SWAP_EFFECT_DISCARD, in DirectX 12, I get the following error:
IDXGIFactory::CreateSwapChain: This D3D API version requires the swap effect to be one of DXGI_SWAP_EFFECT_FLIP_*.

So I guess the BitBlit model is no longer supported. 🙁

I guess a logical alternative would then be to do something equivalent ‘manually’, but it seems like doing something like this would lose one of the advantages of the trick, as it works out in DirectX 9, which is the smooth update during resizing without needing to intercept resize events and update stuff in response to these, in the application code.

What I’d like to see, ideally, are links to working code that does something equivalent to what I’m doing in DirectX 9, in DirectX 12, OpenGL, or Vulkan.

If it helps to see the code in action, and the resulting resize behaviour, you can see this in the PathEngine graphical testbed, which can be downloaded here: https://pathengine.com/downloads
(And I could also look at stripping out and posting source code for a minimal example application that demonstrates this behaviour, if this would help.)

Could Bitcoin have a fixed level of difficulty?

Could Bitcoin have a fixed difficulty in how to implement this for a test and what would that mean for mining? Would there be a difference if you were to dismantle with a large rig or just a wallet?

c ++ division safe from overflow for fixed point

Therefore, I examined the overflow-proof subdivision for a class that uses an int64 element with a certain RESOLUTION (10000) for the fraction. To get the precision of the fraction during a simple division, you would first multiply by the resolution. If the number is large enough, it will overflow. I came up with an algorithm to share without overflow, but I think it could probably be better optimized. At first glance, I can't see how:

``````int64 divideOverflowSafe( const int64 Lhs, const int64 Rhs ) const
{
// The idea here is simple, split Lhs * RESOLUTION / Rhs into two separate divisions to avoid the multiplication by RESOLUTION and thus avoid the overflow
const int64 FracPart = m_nVal % RESOLUTION;
const int64 DecPart = m_nVal - FracPart;

// Just dividing the integral part means there's already an inherent resolution buffer for precision. We then need to also calculate the remainder, which is small enough that it can be multiplied by RESOLUTION ( and needs to be, to maintain precision )
const int64 Res1 = DecPart / b.m_nVal;
const int64 Res1Remainder = ( DecPart % b.m_nVal ) * RESOLUTION / b.m_nVal;

// The fractional part is small enough to be multiplied by RESOLUTION, again for precision reasons
const int64 Res2 = FracPart * RESOLUTION / b.m_nVal;

// At the end we add everything back together to obtain the result
const int64 Res = Res1 * RESOLUTION + Res1Remainder + Res2;
return Res;
}
``````

I'm designing an intranet application for a client that shows notifications about a fixed flyout pattern in combination with a notification icon in the header menu. The picture says more than words can;)
The notifications should remain in focus as they should be read by users. However, if the user wants to add something with and symbol in the same menu (in this case the symbol & # 39; + & # 39;), another flyout menu is displayed above the fixed notifications. It seems a bit strange to me and I can't find a better way. Does anyone have experience with this or better ideas?

thank you

Vending machine – bug in CFG fixed

Here is a CFG that generates the language of the basic arithmetic expressions. These expressions enable the 4 basic operations for arithmetic values ​​a, b and c. It implements a sequence of operations in which multiplication and division take precedence over addition and subtraction, and all operations are left-associative. Parentheses are also implemented. An error has occurred in this CFG.

S → S * T | S / T | T.
T → T + V | T-V | V.
V → (S) | a | b | c

You should rewrite this CFG to do as many of the following tasks as possible:
a) Correct the error in this CFG so that it works as described.
b) Add an exponent operation. This operation should have a higher priority than multiplication and division, but a lower priority than parentheses. The exponent operator is ^. For example, a ^ b would be ab or "a to b". Give this operation, and only this operation, the right associativity so that a ^ b ^ c would be "a to (b to c)".
c) Make these expressions equations. An equation consists of an equality operator {=,<,>} with an expression on each page. The equality operator should have the lowest priority and the equality operator should not be in parentheses.

Does "tensoring" with a fixed field preserve Galois extensions of finite fields?

To let $$K$$ be a (possibly infinite) characteristic field $$p$$, and $$L$$ be a finite field extension of $$mathbb {F} _p$$, in order to $$L$$ is finite and $$L / mathbb {F} _p$$ is Galois. Can we conclude from this? $$(K otimes _ { mathbb {F} _p} L) / K$$ is Galois? If not, under what conditions can this conclusion be drawn?