Series expansion of explicit functions

For the following input,

zv[u_, v_] :=   v + zv1[ u, v]/u; mvu[u, v] := D[zv[u, v], u]; Series[mvu[u, v], {u, 0, 1}] 

the output is

-(zv1[0,v]/u^2)+1/2 zv1^(2,0)[0,v]+1/3 u zv1^(3,0)[0,v]+O[u^2] 

I want the series expansion without expansion of zv1[u, v] around 0 (basically the output should be

 zv1^(1,0)[u,v]/u - zv1[u,v]/u^2 

Is there a general method to do this?

RGBD alignment without explicit transformation between RGB and depth

I have a set of RGB-D scans of the same scene, corresponding camera poses, intrinsics and extrinsics for both color and depth cameras. RGB’s resolution is 1290×960, depth’s is 640×480.

Depth is pretty accurate, but still noisy, the same with camera poses. However, both intrinsics and extrinsics are not very accurate: for example, intrinsics does not introduce any distortion terms, while images are definitely distorted. Extrinsics tell that both cameras take place exactly at the same point, since they are just identity matrices. It could be decent approximation though.

When I try to compute a point cloud from a frame by downsampling RGB, unprojecting depth, transforming it with RGB extrinsics and projecting with RGB’s intrinsics, it looks like RGB frame is shifted by a few cm from depth – for example, an object’s border could be colored as background.

One might assume that such artifacts could be eliminated by aligning depth to RGB with improved extrinsics. Is there a way to estimate more accurate transformation between RGB and depth in such scenario?

I’m familiar with pretty relevant question, but there you have required Rt matrix for both cameras.

In case of well-performing monocular depth estimation, one could align two point clouds (computed from depth and estimated from RGB) directly and determine required transformation.

Am I missing something and there is well-known approach for this problem?

Does the Alarm Spell need to be explicit for which creatures to ignore?

In the 5e PHB for D&D on page 211 there is a 1st level spell called Alarm.

In the description it has a sentence:

When you cast the spell, you can designate creatures that won’t set off the alarm.

This leaves it a little vague as to whether or not said creatures must be explicitly stated or can general statements be made. It makes sense to explicitly name party members, with the exception of the rogue, that will not set off the alarm. However what about designating creatures by groups? Here are several examples:

  • The city guards won’t set off the alarm (some of which the spell caster knows and others they do not know)
  • Tiny creatures won’t set off the alarm
  • Tiny insects won’t set off the alarm (telling if something is tiny is not too bad, but how would the spell know if the creature is an insect)
  • Good aligned creatures won’t sent off the alarm

So, is there any clarification or restrictions on how or what one can designate which creatures the Alarm spell ignores?

bipartite d regular expender explicit construction

I am looking for an explicit (and simple) construction of a d regular bi bipartite graph which is an expander. I searched the web and didn’t find any sufficient answer. The only explicit graph I did managed to find(and understand) was the margolis graph, but as far as I can understand this graph is not a bipartite (for example (0,0) has a self edge).

Please help me.

Aspect-oriented vs explicit style in Python

Readability counts, but is very subjective. The following snippets are equivalent in functionality and turn a generator iterator into a chunked HTTP response in Flask. Which code snippet do you find more readable and easier to understand?

A) Aspect style with function decorators that change the return value:

@app.route('/') @flask_response_decorator @optional_streaming_decorator @progress_log_decorator def index() -> Iterator:     """Index page, optionally HTTP chunk-streamed and formatted."""     return Foo.get_instance().are_changes_locked() 

or

B) explicit decorators within the function body

@app.route('/') def index() -> flask.Response:     """Index page, optionally HTTP chunk-streamed and formatted."""     response = Foo.get_instance().are_changes_locked()     return flask.Response(optional_iterator_to_stream(iterator_to_progress_log(response))) 

Explicit evaluation of the derivatives of $p$-adic Gamma function at 0

The definition of the $ p$ -adic Gamma function $ \Gamma_p(x)$ for an odd prime number $ p$ can be found in the book “A Course in $ p$ -adic analysis” by A. M. Robert. While the construction of $ \log \Gamma_p(x)$ is also included in the book. The function $ \log \Gamma_p(x)$ is odd, and has a series expansion in the variable $ x$ . For more details, see Chapter 7 of the book. \begin{equation} \log \Gamma_p(x)=(\log \Gamma_p)^{(1)}(0)x+\frac{1}{3!}(\log \Gamma_p)^{(3)}(0)x^3+\frac{1}{5!}(\log \Gamma_p)^{(5)}(0)x^5+\cdots. \end{equation} Since $ \log \Gamma_p(x)$ is an odd function, we have \begin{equation} (\log \Gamma_p)^{(2n)}(0)=0. \end{equation} I am wondering whether there is an explicit method to evaluate the coefficient $ (\log \Gamma_p)^{(s)}(0)$ , at least the first several terms $ (\log \Gamma_p)^{(3)}(0)$ , $ (\log \Gamma_p)^{(5)}(0)$ , and $ (\log \Gamma_p)^{(7)}(0)$ ?

One helpful observations is that since we have \begin{equation} \Gamma_p(0)=1, \end{equation} so $ (\log \Gamma_p)^{(s)}(0)$ can be computed by \begin{equation} \Gamma_p^{‘}(0),\Gamma^{”}_p(0),\Gamma^{”’}_p(0), \cdots,\Gamma^{(s)}_p(0). \end{equation} So this question is equivalent to evaluate $ \Gamma_p^{‘}(0),\Gamma^{”}_p(0),\Gamma^{”’}_p(0),\cdots$ . Does anyone know an explicit formula to compute them?

Explicit bivariate quadratic polynomials where Coppersmith is better than standard solver?

http://www.numbertheory.org/pdfs/general_quadratic_solution.pdf gives a general method to solve quadratic bivariate diophantine equation while Coppersmith introduced a method to solve bivariate polynomials which work provably and have been shown to break $ RSA$ system if half of low significant bits of either $ P$ or $ Q$ are known.

The equation that comes out is $ $ (2^ku+v)(2^ku’+v’)=PQ$ $ where if we assume $ v$ is known. Then $ vv’\equiv PQ\bmod 2^k$ gives $ v’$ .

So we have a quadratic diophantine equation $ $ 2^kuu’+(uv’+u’v)=\frac{PQ-vv’}{2^k}.$ $

Why do I need Coppersmith’s method to solve this? Can’t a regular diophantine solver work here and so are there explicit polynomials where Coppersmith is better than standard solver in bivariate quadratic case?

An explicit formula for characteristic polynomial of matrix tensor product

Consider two polynomials P and Q and their companion matrices. It seems that char polynomial of tensor product of said matrices would be a polynomial with roots that are all possible pairs product of roots of P,Q.

I guess its coefficients could be expressed through coefficients of P and Q. But I don’t know the explicit formula and I cannot find it. I also failed to find it out myself — I tried different approaches. Maybe it should be that characteristic polynomial, maybe resultant of some form, but..

I hope this is done by someone already.

Explicit Song Checker

To stay in practice with my python I’ve decided to write an explicit song checker. It checks each word in the song against an array of explicit words contained in the file. I’ve decided not to include the words that are to be checked against, for I am not sure about the rule of having explicit words in a programs code. Feedback on efficiency and structure is what I’m going for mostly. Style and other critiques are invited as well.

explicit_song_checker.py

explicit_words = [     #explicit words not shown  ]  def isClean(song_path):     with open(song_path) as song:         for line in song:             words = line.split(" ")             for word in words:                 for explicit_word in explicit_words:                     if word == explicit_word:                         return False          return True  def main():     song = raw_input("Enter path to song: \n")     if isClean(song):         print("CLEAN")     else:         print("EXPLICIT")  if __name__ == '__main__':     main()