The dot product inclination is correct, and that includes the sum you need. So, to get the sum of the products of the elements of a target array and a set of weights:

>>> a = np.array([[0,1,2],[2,2,3]])
>>> a
array([[0, 1, 2],
       [2, 2, 3]])
>>> weights = np.array([16,4,2])
>>> np.dot(a,weights)
array([ 8, 46])

Since intervals (-0.25, -0.20), (-0.20, -0.10) and (-0.10, 0.15) are actually subintervals of partition of an interval (-0.25, 0.15) you could find indices where elements should be inserted in A to maintain order. They specify slices of B to perform addition on. In short:

partition = np.array([-0.25, -0.20, -0.10, 0.15])
weights = np.array([1, 0.5, 2])
out = []
for n in A:
    idx = np.searchsorted(A, n + partition)
    results = np.add.reduceat(B[:idx[-1]], idx[:-1])
    out.append(np.dot(results, weights))
>>> print(out)
[7.5, 7.5, 8.0, 10.5, 12.0, 11.0, 11.5, 11.5, 6.5, 13.5, 27.5, 27.5, 31.5, 35.5, 37.5, 37.0, 36.0, 35.0, 34.0, 34.5, 34.0, 36.5, 33.0, 34.0, 34.5, 34.5, 36.0, 39.0, 37.0, 36.0, 37.0, 36.5, 37.5, 39.0, 36.5, 37.5, 34.0, 31.0, 27.5, 23.0]

Note that results are wrong if there are empty slices of B

Even a 'technically' correct answer has been all ready given, I'll give my straightforward answer:

from numpy import array, dot
dot(array([0.5, -1]), array([[1, 2, 3], [4, 5, 6]]))
# array([-3.5 -4. -4.5])

This one is much more on with the spirit of linear algebra (and as well those three dotted requirements on top of the question).

Update: And this solution is really fast, not marginally, but easily some (10- 15)x faster than all ready proposed one!

The method numpy.einsum is convenient for this:

np.einsum('ij,kli->klj', A, B)

The notation says: multiply A[i, j] by B[k, l, i] and sum over i; place the result in the cell [k, l, j].

Example:

A = np.array([(255, 0, 0), (0, 255, 0), (0, 0, 255)])
B = np.array([[[0.2, 0.6, 0.20], [0.2, 0.2, 0.60]], [[0.4, 0.4, 0.2], [0.3, 0.3, 0.4]]])
Y = np.einsum('ij,kli->klj', A, B)

Then Y is

array([[[  51. ,  153. ,   51. ],
        [  51. ,   51. ,  153. ]],

       [[ 102. ,  102. ,   51. ],
        [  76.5,   76.5,  102. ]]])

I think you want something like:

import numpy as np
from scipy.ndimage import convolve

length_l = 10
time_l = 10
u = np.zeros((length_l, length_l))# (x,y)
u[:,  0] = 1
u[:, -1] = 1

alpha = .1
weights = np.array([[ 0,  1,  0],
                    [ 1, -4,  1],
                    [ 0,  1,  0]])

for i in range(5):
    u += alpha * convolve(u, weights)
    print(u)

You could reduce down a bit by doing:

weights = alpha * weights
weights[1, 1] = weights[1, 1] + 1

for i in range(5):
    u = convolve(u, weights)
    print(u)

You can achieve this result with numpy.select and a dictionary summarizing your conditions.

arr = np.array([[0.001, 0.02], [0.3, 0.9]])
selection_dict = {10: (0<=arr)&(arr<0.05),
                  5:  (0.05<=arr)&(arr<1.0)}

In [52]: np.select(condlist=selection_dict.values(), choicelist=selection_dict.keys())
Out[52]: 
array([[10, 10],
       [ 5,  5]])

NOTE: I'm using Python 3.6.0

You can try using itertools: https://docs.python.org/3/library/itertools.html

The itertools.accumulate function was shown to possibly be faster than np.cumsum: https://stackoverflow.com/a/39534850/7175945

from itertools import accumulate

def weighted():
    discount_rate = 0.95 #your discount rate
    rewards = [0, 0, 10] # want to translate to: 9, 9.5, 10
    reversed_rewards = rewards[::-1] #list reversal
    acc = list(accumulate(reversed_rewards, lambda x,y: x*discount_rate + y))
    return acc[::-1] 

print(weighted())

I think this should be what you're looking for if you truly don't want to use numpy, otherwise what you already have written is also a viable option.