Proving that a sum of n zeros are 0

Define a function $ \text{zeros} \colon \textsf{nat} \to \textsf{natlist}$ that, given a natural $ n$ , produces a list of $ n$ zeroes.

You can use either Coq notation or, if you’re comfortable with it, mathematical notation.

Prove the following theorem about your function.

Theorem: For all natural numbers $ n$ , we have $ \text{sum_natlist}(\text{zeros}(n)) = 0$ .

Avoiding zeros in ArrayReshape

Consider the list list={1,2,3,4,5,6,7,8} and imagine I wanted to change it to {{1,2,3},{4,5,6},{7,8}}. How can I do this?

Using ArrayReshape in the usual manner

list = {1, 2, 3, 4, 5, 6, 7, 8}; ArrayReshape[list, {3, 3}] 

yields {{1, 2, 3}, {4, 5, 6}, {7, 8, 0}}. Is it possible to use ArrayReshape and avoid that extra 0 at the end? Essentially, I want to reshape my list according to it’s size.

After running through my algorithm fine, my array returns as all zeros

I’ve spent a long time finally getting my algorithm in Python to invert Laplace transforms and live plot them to work, but unfortunately, although it seems to run fine within the function, it continuously just plots zeros!

Blue = estimation(shouldn't be zero!), Red = actual

I’ve wasted so much time getting this thing to work, and now I have no clue what could be wrong. So forgive me but I think I’ll have to post the whole thing.

The equation this is based on is a series-integral and it iterates until the series converges. However, it converges super slowly so I used Aitken’s delta-squared method to speed the whole thing up. The goal is to populate array y with each Aitken’s iteration from 0.000001 to 10 and then compare the estimation’ integral with the previous iteration’s if a random point in the former is close enough to the latter. This loops until the integrals have a difference of less than 0.01 or a set amount of iterations is reached (~30000).

This happens for 6 equations simultaneously using parallel processing. The graph live plots all 6 (in blue) compared to each of the actual equations they’re converging towards (in red) using matplotlib.

For debugging, I basically tried putting a bunch of print statements everywhere in the f_u function to see what was going on. Everything looked like it was going fine. But in the __main__ function and plot functions when I did the same, I was getting all zeros for the same array. I thought it was a local vs. global issue so I put global y in the plot and f_u, with no luck.

I know this isn’t doing this due to the parallelization; I tried without it with no luck. Basically, I suggest looking at what y does between the f_u function and the __main__ function, thats where the relationship with the y arrays breaks down I think, I just don’t know what to do to fix it.

To execute this, you’re gonna need all the packages in the import statement, including numba. You can remove the @jit decorations on the Laplace functions if you don’t want numba, but it will be sloooooow.

Here it is:

import matplotlib.pyplot as plt from matplotlib import style from matplotlib import animation import numpy as np from scipy.integrate import quad, simps from scipy.special import jv import math import random import datetime import multiprocessing as mp from numba import jit  start = datetime.datetime.now()     # Record time start  # Initialize plot style.use('fivethirtyeight')  fig, axes = plt.subplots(3, 2) ((ax1, ax2), (ax3, ax4), (ax5, ax6)) = axes  plt.autoscale(enable=True)  for ax in axes.flat:     ax.label_outer()  # Initialize variables gamma = np.array([np.nan, 1, 1, 0, 1.5, 2, 1])    # Bromwich contour parameter for each equation num = 6     # Number of equations to be processed in total n = 0   # Repetition constant for equation 3, set to either zero or 1 (diverges at 1) max_count = 1000   # Number of data points in x and y epsilon = 10 ** -40     # Minimum number to divide by in Aitken's iteration err = 10 ** -4    # Maximum difference in y to trigger comparison in closing() max_err = 0.01    # Maximum difference in integrals computed in closing() to end iteration process  x_0 = 0     # Set first integral to 0 for now result = np.zeros(7)    # Vector to store Aitken's iteration for closing() comparison previous = np.zeros(7)     # Vector to store iteration before Aitken's for closing() comparison end = np.zeros(7)     # Vector to store end conditions -- running = 0, ended = 1  u, step = np.linspace(0.000001, 10, max_count, retstep=True)    # Initializing x values  y = np.empty([num, 4, max_count])     # Initializing y values -- form is y[equation number][iteration in Aitken's][x value] y_denom = np.empty([num, max_count])    # Initializing array to store Aitken's denominator values for each equation x_iter = np.empty([num, max_count])    # Initializing array to store Aitken's iteration as starting point for next iteration  def printer(num, k):    # Prints the equation number, iteration and y value at 10     if num == 1:         print(str(num) + "    " + str(k) + "    " + str(y[0][3][max_count-1]) + "\n")     elif num == 2:         print(str(num) + "    " + str(k) + "    " + str(y[1][3][max_count-1]) + "\n")     elif num == 3:         print(str(num) + "    " + str(k) + "    " + str(y[2][3][max_count-1]) + "\n")     elif num == 4:         print(str(num) + "    " + str(k) + "    " + str(y[3][3][max_count-1]) + "\n")     elif num == 5:         print(str(num) + "    " + str(k) + "    " + str(y[4][3][max_count-1]) + "\n")     elif num == 6:         print(str(num) + "    " + str(k) + "    " + str(y[5][3][max_count-1]) + "\n")  def plot1():    # Plots estimation 1 (blue) and actual equation 1 (red)     global y     ax1.clear()     line1, = ax1.plot(u, y[0][3][0:max_count])     ax1.plot(u, np.sin(u), 'tab:red')     return line1,  def plot2():    # Plots estimation 2 (blue) and actual equation 2 (red)     global y     ax2.clear()     line2, = ax2.plot(u, y[1][3][0:max_count])     ax2.plot(u, np.heaviside(u, 1), 'tab:red')     return line2,  def plot3():    # Plots estimation 3 (blue) and actual equation 3 (red)     global y     ax3.clear()     line3, = ax3.plot(u, y[2][3][0:max_count])     ax3.plot(u, np.cos(2 * np.sqrt(u)) / np.sqrt(np.pi * u), 'tab:red')     return line3,  def plot4():    # Plots estimation 4 (blue) and actual equation 4 (red)     global y     ax4.clear()     line4, = ax4.plot(u, y[3][3][0:max_count])     ax4.plot(u, np.log(u), 'tab:red')     return line4,  def plot5():    # Plots estimation 5 (blue) and actual equation 5 (red)     global y     ax5.clear()     line5, = ax5.plot(u, y[4][3][0:max_count])     ax5.plot(u, np.heaviside(u - 1, 1) - np.heaviside(u - 2, 1), 'tab:red')     return line5,  def plot6():    # Plots estimation 6 (blue) and actual equation 6 (red)     global y     ax6.clear()     line6, = ax6.plot(u, y[5][3][0:max_count])     ax6.plot(u, jv(0, u), 'tab:red')     return line6,  def animate(i):     # Plots all equations, used to live-update graph     ln1, = plot1()     ln2, = plot2()     ln3, = plot3()     ln4, = plot4()     ln5, = plot5()     ln6, = plot6()     return ln1, ln2, ln3, ln4, ln5, ln6,  @jit(nopython=True, cache=True) def f_p1(omega, u, k):      # Equation 1, Laplace form     b = (omega + k * np.pi) / u     a = gamma[1]      f1 = a * (1 / (a ** 2 + (b + 1) ** 2) + 1 / (a ** 2 + (b - 1) ** 2)) * np.cos(omega)     return f1  @jit(nopython=True, cache=True) def f_p2(omega, u, k):      # Equation 2, Laplace form     b = (omega + k * np.pi) / u     a = gamma[2]      f2 = a / (a ** 2 + b ** 2) * np.cos(omega)     return f2  @jit(nopython=True, cache=True) def f_p3(omega, u, k):      # Equation 3, Laplace form     b = (omega + k * np.pi) / u     a = gamma[3]      f3 = np.e ** (-a / (a ** 2 + b ** 2)) * (a ** 2 + b ** 2) ** (1 / 4) * np.cos(         (math.atan2(b, a) + 2 * n * np.pi) / 2) * np.cos(b / (a ** 2 + b ** 2)) / (                 np.sqrt(a ** 2 + b ** 2) * (np.cos((math.atan2(b, a) + 2 * n * np.pi) / 2) ** 2 + np.sin(                     (math.atan2(b, a) + 2 * n * np.pi) / 2))) * np.cos(omega)     return f3  @jit(nopython=True, cache=True) def f_p4(omega, u, k):      # Equation 4, Laplace form     b = (omega + k * np.pi) / u     a = gamma[4]      f4 = -(a * np.log(a ** 2 + b ** 2) + a * np.e) / (a ** 2 + b ** 2) * np.cos(omega)     return f4  @jit(nopython=True, cache=True) def f_p5(omega, u, k):      # Equation 5, Laplace form     b = (omega + k * np.pi) / u     a = gamma[5]      f5 = a * (np.e ** (-a) * np.cos(b) - np.e ** (-2 * a) * np.cos(2 * b)) / (a ** 2 + b ** 2) * np.cos(omega)     return f5  @jit(nopython=True, cache=True) def f_p6(omega, u, k):      # Equation 6, Laplace form     b = (omega + k * np.pi) / u     a = gamma[6]      f6 = np.sqrt((a ** 2 - b ** 2 + 1) ** 2 + (2 * a * b) ** 2) * np.cos(         (math.atan2(2 * a * b, a ** 2 - b ** 2 + 1) + 2 * n * np.pi) / 2) / (             ((a ** 2 - b ** 2 + 1) ** 2 + (2 * a * b) ** 2) * (                 np.cos((math.atan2(2 * a * b, a ** 2 - b ** 2 + 1) + 2 * n * np.pi) / 2) ** 2 + np.sin(                     (math.atan2(2 * a * b, a ** 2 - b ** 2 + 1) + 2 * n * np.pi) / 2) ** 2)) * np.cos(omega)     return f6  def closing(result, previous, num, k):    # Checks for convergence. If so, adds each term to f_0 and ends process     if abs(result - previous) < max_err:         diff = abs(result - previous)          print("Equation " + str(num) + " converges to " + str(diff) + " with " + str(k) + " iterations." + "\n")          if num == 1:             for i in range(max_count):                 y[0][3][i] += f_0(num, i)             end[1] += 1             return 1         elif num == 2:             for i in range(max_count):                 y[1][3][i] += f_0(num, i)             end[2] += 1             return 1         elif num == 3:             for i in range(max_count):                 y[2][3][i] += f_0(num, i)             end[3] += 1             return 1         elif num == 4:             for i in range(max_count):                 y[3][3][i] += f_0(num, i)             end[4] += 1             return 1         elif num == 5:             for i in range(max_count):                 y[4][3][i] += f_0(num, i)             end[5] += 1             return 1         elif num == 6:             for i in range(max_count):                 y[5][3][i] += f_0(num, i)             end[6] += 1             return 1     else:         print("Equation " + str(num) + " has not yet converged.\n")         return 0  def f_0(num, i):     # Initial integral in the series. Added at end after closing() convergence test     if num == 1:         x_0 = 2 * np.e ** (gamma[num] * u[i]) / (np.pi * u[i]) * quad(             f_p1, 0, np.pi / 2, args=(u[i], 0))[0]     elif num == 2:         x_0 = 2 * np.e ** (gamma[num] * u[i]) / (np.pi * u[i]) * quad(             f_p2, 0, np.pi / 2, args=(u[i], 0))[0]     elif num == 3:         x_0 = 2 * np.e ** (gamma[num] * u[i]) / (np.pi * u[i]) * quad(             f_p3, 0, np.pi / 2, args=(u[i], 0))[0]     elif num == 4:         x_0 = 2 * np.e ** (gamma[num] * u[i]) / (np.pi * u[i]) * quad(             f_p4, 0, np.pi / 2, args=(u[i], 0))[0]     elif num == 5:         x_0 = 2 * np.e ** (gamma[num] * u[i]) / (np.pi * u[i]) * quad(             f_p5, 0, np.pi / 2, args=(u[i], 0))[0]     elif num == 6:         x_0 = 2 * np.e ** (gamma[num] * u[i]) / (np.pi * u[i]) * quad(             f_p6, 0, np.pi / 2, args=(u[i], 0))[0]      return x_0  def f_u(u, num):    # Main algorithm. Here, the summation integrals iterate     global y, result, previous    # Forces retrieval of from global of these arrays? (attempt to debug)     k = 1   # Number of iterations      for i in range(max_count):  # First overall series iteration (initial 1st)         if num == 1:             y[0][0][i] = 2 * np.e ** (gamma[num] * u[i]) / (np.pi * u[i]) * (-1) ** k * quad(                 f_p1, -np.pi / 2, np.pi / 2, args=(u[i], k))[0]         elif num == 2:             y[1][0][i] = 2 * np.e ** (gamma[num] * u[i]) / (np.pi * u[i]) * (-1) ** k * quad(                 f_p2, -np.pi / 2, np.pi / 2, args=(u[i], k))[0]         elif num == 3:             y[2][0][i] = 2 * np.e ** (gamma[num] * u[i]) / (np.pi * u[i]) * (-1) ** k * quad(                 f_p3, -np.pi / 2, np.pi / 2, args=(u[i], k))[0]         elif num == 4:             y[3][0][i] = 2 * np.e ** (gamma[num] * u[i]) / (np.pi * u[i]) * (-1) ** k * quad(                 f_p4, -np.pi / 2, np.pi / 2, args=(u[i], k))[0]         elif num == 5:             y[4][0][i] = 2 * np.e ** (gamma[num] * u[i]) / (np.pi * u[i]) * (-1) ** k * quad(                 f_p5, -np.pi / 2, np.pi / 2, args=(u[i], k))[0]         elif num == 6:             y[5][0][i] = 2 * np.e ** (gamma[num] * u[i]) / (np.pi * u[i]) * (-1) ** k * quad(                 f_p6, -np.pi / 2, np.pi / 2, args=(u[i], k))[0]      for j in range(10000):   # Iteration loop. Goes until closing() or k = ~30000 for each equation         if j > 0:             for i in range(max_count):  # Sets the first iteration (out of 3 for Aitken's) equal to the previous Aitken's or the first iteration if j = 0 (1st)                 if num == 1:                     y[0][0][i] = x_iter[0][i]                 elif num == 2:                     y[1][0][i] = x_iter[1][i]                 elif num == 3:                     y[2][0][i] = x_iter[2][i]                 elif num == 4:                     y[3][0][i] = x_iter[3][i]                 elif num == 5:                     y[4][0][i] = x_iter[4][i]                 elif num == 6:                     y[5][0][i] = x_iter[5][i]             else:                 k += 1          for i in range(max_count):  # Second iteration for Aitken's (2nd)             if num == 1:                 y[0][1][i] = 2 * np.e ** (gamma[num] * u[i]) / (np.pi * u[i]) * (-1) ** k * quad(                     f_p1, -np.pi / 2, np.pi / 2, args=(u[i], k))[0]             elif num == 2:                 y[1][1][i] = 2 * np.e ** (gamma[num] * u[i]) / (np.pi * u[i]) * (-1) ** k * quad(                     f_p2, -np.pi / 2, np.pi / 2, args=(u[i], k))[0]             elif num == 3:                 y[2][1][i] = 2 * np.e ** (gamma[num] * u[i]) / (np.pi * u[i]) * (-1) ** k * quad(                     f_p3, -np.pi / 2, np.pi / 2, args=(u[i], k))[0]             elif num == 4:                 y[3][1][i] = 2 * np.e ** (gamma[num] * u[i]) / (np.pi * u[i]) * (-1) ** k * quad(                     f_p4, -np.pi / 2, np.pi / 2, args=(u[i], k))[0]             elif num == 5:                 y[4][1][i] = 2 * np.e ** (gamma[num] * u[i]) / (np.pi * u[i]) * (-1) ** k * quad(                     f_p5, -np.pi / 2, np.pi / 2, args=(u[i], k))[0]             elif num == 6:                 y[5][1][i] = 2 * np.e ** (gamma[num] * u[i]) / (np.pi * u[i]) * (-1) ** k * quad(                     f_p6, -np.pi / 2, np.pi / 2, args=(u[i], k))[0]          k += 1          for i in range(max_count):  # Third iteration for Aitken's (3rd)             if num == 1:                 y[0][2][i] = 2 * np.e ** (gamma[num] * u[i]) / (np.pi * u[i]) * (-1) ** k * quad(                     f_p1, -np.pi / 2, np.pi / 2, args=(u[i], k))[0]             elif num == 2:                 y[1][2][i] = 2 * np.e ** (gamma[num] * u[i]) / (np.pi * u[i]) * (-1) ** k * quad(                     f_p2, -np.pi / 2, np.pi / 2, args=(u[i], k))[0]             elif num == 3:                 y[2][2][i] = 2 * np.e ** (gamma[num] * u[i]) / (np.pi * u[i]) * (-1) ** k * quad(                     f_p3, -np.pi / 2, np.pi / 2, args=(u[i], k))[0]             elif num == 4:                 y[3][2][i] = 2 * np.e ** (gamma[num] * u[i]) / (np.pi * u[i]) * (-1) ** k * quad(                     f_p4, -np.pi / 2, np.pi / 2, args=(u[i], k))[0]             elif num == 5:                 y[4][2][i] = 2 * np.e ** (gamma[num] * u[i]) / (np.pi * u[i]) * (-1) ** k * quad(                     f_p5, -np.pi / 2, np.pi / 2, args=(u[i], k))[0]             elif num == 6:                 y[5][2][i] = 2 * np.e ** (gamma[num] * u[i]) / (np.pi * u[i]) * (-1) ** k * quad(                     f_p6, -np.pi / 2, np.pi / 2, args=(u[i], k))[0]          k += 1          for i in range(max_count):  # Aitken's delta-squared method iteration using the previous 3 (4th)             if num == 1:                 y_denom[0][i] = (y[0][2][i] - y[0][1][i]) - (y[0][1][i] - y[0][0][i])                  if abs(y_denom[0][i]) < epsilon:                     print("Denominator too small to calculate. Exiting...\n")                     return 9                  y[0][3][i] = y[0][2][i] - ((y[0][2][i] - y[0][1][i]) ** 2) / y_denom[0][i]             elif num == 2:                 y_denom[1][i] = (y[1][2][i] - y[1][1][i]) - (y[1][1][i] - y[1][0][i])                  if abs(y_denom[1][i]) < epsilon:                     print("Denominator too small to calculate. Exiting...\n")                     return 9                  y[1][3][i] = y[1][2][i] - ((y[1][2][i] - y[1][1][i]) ** 2) / y_denom[1][i]             elif num == 3:                 y_denom[2][i] = (y[2][2][i] - y[2][1][i]) - (y[2][1][i] - y[2][0][i])                  if abs(y_denom[2][i]) < epsilon:                     print("Denominator too small to calculate. Exiting...\n")                     return 9                  y[2][3][i] = y[2][2][i] - ((y[2][2][i] - y[2][1][i]) ** 2) / y_denom[2][i]             elif num == 4:                 y_denom[3][i] = (y[3][2][i] - y[3][1][i]) - (y[3][1][i] - y[3][0][i])                  if abs(y_denom[3][i]) < epsilon:                     print("Denominator too small to calculate. Exiting...\n")                     return 9                  y[3][3][i] = y[3][2][i] - ((y[3][2][i] - y[3][1][i]) ** 2) / y_denom[3][i]             elif num == 5:                 y_denom[4][i] = (y[4][2][i] - y[4][1][i]) - (y[4][1][i] - y[4][0][i])                  if abs(y_denom[4][i]) < epsilon:                     print("Denominator too small to calculate. Exiting...\n")                     return 9                  y[4][3][i] = y[4][2][i] - ((y[4][2][i] - y[4][1][i]) ** 2) / y_denom[4][i]             elif num == 6:                 y_denom[5][i] = (y[5][2][i] - y[5][1][i]) - (y[5][1][i] - y[5][0][i])                  if abs(y_denom[5][i]) < epsilon:                     print("Denominator too small to calculate. Exiting...\n")                     return 9                  y[5][3][i] = y[5][2][i] - ((y[5][2][i] - y[5][1][i]) ** 2) / y_denom[5][i]          k += 1         printer(num, k)          rand = random.randrange(0, max_count)   # Setting random number for x value          # Comparison between y at random x in Aitken's vs the previous iteration. If close enough, triggers closing()         if num == 1:             if abs(y[0][3][rand] - y[0][2][rand]) < err:                 result[num] = simps(y[0][3][0:max_count], u, dx=step)   #Integrates Aitken's iteration (4th)                 previous[num] = simps(y[0][2][0:max_count], u, dx=step)    #Integrates integration before Aitken's (3rd)                 c1 = closing(result[num], previous[num], num, k)                 if c1 == 1:                     break         elif num == 2:             if abs(y[1][3][rand] - y[1][2][rand]) < err:                 result[num] = simps(y[1][3][0:max_count], u, dx=step)                 previous[num] = simps(y[1][2][0:max_count], u, dx=step)                 c2 = closing(result[num], previous[num], num, k)                 if c2 == 1:                     break         elif num == 3:             if abs(y[2][3][rand] - y[2][2][rand]) < err:                 result[num] = simps(y[2][3][0:max_count], u, dx=step)                 previous[num] = simps(y[2][2][0:max_count], u, dx=step)                 c3 = closing(result[num], previous[num], num, k)                 if c3 == 1:                     break         elif num == 4:             if abs(y[3][3][rand] - y[3][2][rand]) < err:                 result[num] = simps(y[3][3][0:max_count], u, dx=step)                 previous[num] = simps(y[3][2][0:max_count], u, dx=step)                 c4 = closing(result[num], previous[num], num, k)                 if c4 == 1:                     break         elif num == 5:             if abs(y[4][3][rand] - y[4][2][rand]) < err:                 result[num] = simps(y[4][3][0:max_count], u, dx=step)                 previous[num] = simps(y[4][2][0:max_count], u, dx=step)                 c5 = closing(result[num], previous[num], num, k)                 if c5 == 1:                     break         elif num == 6:             if abs(y[5][3][rand] - y[5][2][rand]) < err:                 result[num] = simps(y[5][3][0:max_count], u, dx=step)                 previous[num] = simps(y[5][2][0:max_count], u, dx=step)                 c6 = closing(result[num], previous[num], num, k)                 if c6 == 1:                     break          for i in range(max_count):  # Setting current Aitken's iteration to first iteration             if num == 1:                 x_iter[0][i] = y[0][3][i]             elif num == 2:                 x_iter[1][i] = y[1][3][i]             elif num == 3:                 x_iter[2][i] = y[2][3][i]             elif num == 4:                 x_iter[3][i] = y[3][3][i]             elif num == 5:                 x_iter[4][i] = y[4][3][i]             elif num == 6:                 x_iter[5][i] = y[5][3][i]      # If iteration limit reached, sets process closing condition to 1 and returns to main     end[num] = 1     return  if __name__ == '__main__':     i = 0      # Define and begin processes, one for each equation     p1 = mp.Process(target=f_u, args=(u, 1))     p2 = mp.Process(target=f_u, args=(u, 2))     p3 = mp.Process(target=f_u, args=(u, 3))     p4 = mp.Process(target=f_u, args=(u, 4))     p5 = mp.Process(target=f_u, args=(u, 5))     p6 = mp.Process(target=f_u, args=(u, 6))      p1.start()     p2.start()     p3.start()     p4.start()     p5.start()     p6.start()      # While any equation is running, update and show the plot every second     while end[1] != 1 or end[2] != 1 or end[3] != 1 or end[4] != 1 or end[5] != 1 or end[6] != 1:         animation.FuncAnimation(fig, animate, interval=1000, blit=True)         plt.pause(1)         plt.show(block=False)         plt.pause(1)      # Joining and closing each process when complete     p1.join()     p1.terminate()     p2.join()     p2.terminate()     p3.join()     p3.terminate()     p4.join()     p4.terminate()     p5.join()     p5.terminate()     p6.join()     p6.terminate()      end = datetime.datetime.now()   # Record time end      print("Runtime: " + str(end - start))      # Updates and plots final result     animate(i)     plt.show()      exit(0) 

Hope you can help me out. Thanks in advance.

LSTM returning only zeros (pytorch)

After succesfully implementing a LSTM “from scratch” based on linear layers, I decided to start using the existing LSTM class to make things easier and gain in performance. But somehow when I try it, it only returns tensors full of zeros. Here is the model :

class pytorchLSTM(nn.Module):     def __init__(self,input_size,hidden_size):         super().__init__()         self.input_size = input_size         self.hidden_size = hidden_size         self.lstm = nn.LSTM(input_size, hidden_size)         self.softmax = nn.LogSoftmax(dim = 1)      def forward(self, input):         out, hidden = self.lstm(input)         out = self.softmax(out)         return out, hidden 

the input is a (1,1,60) tensor represented a one-hot encoded letter :

tensor([[[0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,           0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,           0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,           0., 0., 0., 0., 0., 0., 0., 1., 0.]]]) 

and the models returns, invariably (I tried modifying the values inside of the input, but the result is always the same) :

tensor([[[0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,            0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,            0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,            0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,            0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,            0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]]],         grad_fn=<LogSoftmaxBackward>) 

Any idea where my mistake is and what I understood wrong about the LSTM class ?

Why iterative code times out for calculating the number of trailing zeros in A factorial

Both the codes caluclate the trailing number of zeros in A!.

Here is the iterative code : It times out for large input

public int trailingZeroes(int A) {   int count=0;   for(int i=5;A/5>=1;i=i*5)  {     count+=A/i;  }   return count; } 

And here is the recursive code and it gets completed in time.

public int trailingZeroes(int A) {  return A==0?0:(A/5 + trailingZeroes(A/5)); } 

Does in all cases, recursive codes are faster than iterative codes ? e.g. Tree Traversals etc.

Accounting for zeros in Time Series data

Hi I am transforming my current data set into time series by dividing it into weeks and counts for each week. Currently the weeks where the counts are zero its omitting in the data set for example. Below is the example data set. I want to include all the weeks with counts zero as well. How do i transform it using dplyr.

week counts 2013-10-6 1 2014-08-03 1 2014-10-12 1