How can I effectively use reduce() to optimize my runtime here?

Question

I'm trying to optimize my critical path. source_and_dest is a list of coordinates, state is a translation from one coordinate to another, and distance_squared is a two-dimensional list describing a relationship between two coordinates. My current approach, which is correct, is the following:

e = 0
for source, dest in self.source_and_dest:
   e += self.distance_squared[self.state[source]][self.state[dest]]

However, I run these lines millions of times and I need to improve my runtime (even if only slightly). My cumulative runtime for this is around 6.2s (with other benchmarks, this will grow to be much larger). My understanding is that using functools.reduce() could improve runtime. My attempt, however, gave me much worse runtime (2x worse).

    def do_sum(self,x1, x2):
        if type(x1) == int:
            return x1 + self.distance_squared[self.state[x2[0]]][ self.state[x2[1]]]
        else:
            return self.distance_squared[self.state[x1[0]]][ self.state[x1[1]] ] + self.distance_squared[self.state[x2[0]]][ self.state[x2[1]] ]

...

e=functools.reduce(self.do_sum, self.source_and_dest)

I imagine there may be a way to use reduce() more effectively here, rather than having to check for the x1's type and without so many nested array accesses.

Here is some runnable code. Both approaches are included:

import functools
import cProfile

def torus_min_distance_xy( sourcexy, sinkxy, Nx,Ny ):
    source_x = sourcexy % Nx
    source_y = sourcexy // Nx
    sink_x = sinkxy % Nx
    sink_y = sinkxy // Nx
    if( source_x <= sink_x and source_y <= sink_y ):
        return (( sink_x - source_x ), ( sink_y - source_y ))
    elif( source_x > sink_x and source_y <= sink_y ):
        return (( Nx + sink_x - source_x ) , ( sink_y - source_y ))
    elif( source_x <= sink_x and source_y > sink_y ):
        return (( sink_x - source_x ) , ( Ny + sink_y - source_y ))
    else:
        return (( Nx - source_x + sink_x ) , ( Ny - source_y + sink_y ))

class Energy:
    def __init__( self ):
        self.Nx = 8
        self.Ny = 9
        self.memoized_source_pe_and_dest_partitions = [(56, 5), (12, 33), (68, 14), (53, 15), (28, 33), (7, 24), (57, 5), (14, 22), (22, 28), (32, 19), (1, 28), (66, 17), (58, 0), (69, 14), (55, 7), (63, 12), (52, 15), (17, 22), (62, 12), (59, 0), (54, 7), (8, 29), (65, 1), (33, 29), (0, 32), (31, 70), (67, 17), (19, 24), (61, 8), (60, 8), (64, 1), (29, 32), (15, 31), (5, 19), (24, 31), (38, 16), (3, 26), (50, 9), (35, 4), (20, 26), (10, 23), (39, 16), (9, 18), (18, 20), (21, 25), (11, 20), (48, 2), (40, 6), (51, 9), (37, 10), (45, 3), (34, 4), (2, 18), (44, 3), (41, 6), (36, 10), (13, 30), (47, 11), (26, 30), (6, 21), (27, 71), (49, 2), (25, 23), (43, 13), (42, 13), (46, 11), (30, 21), (4, 27), (16, 25), (23, 27)]
        self.memoized_distance_squared = [[0 for a in range(self.Nx*self.Ny)] for b in range(self.Nx*self.Ny)]

        for source in range(self.Nx*self.Ny):
            for dest in range(self.Nx*self.Ny):
                tmp = torus_min_distance_xy(source,dest,self.Nx,self.Ny)
                self.memoized_distance_squared[source][dest] = (tmp[0]+1)*(tmp[1]+1)

        self.state = [59, 1, 2, 44, 4, 5, 6, 7, 28, 18, 37, 21, 62, 13, 14, 15, 38, 66, 51, 61, 46, 47, 22, 23, 69, 50, 45, 39, 60, 63, 30, 31, 67, 68, 34, 35, 36, 10, 27, 16, 40, 41, 42, 43, 26, 3, 20, 11, 48, 49, 25, 9, 52, 53, 54, 55, 56, 57, 58, 0, 33, 8, 29, 12, 64, 65, 32, 17, 24, 19, 70, 71]

    def do_sum(self, x1, x2):
        if type(x1) == int:
            return x1 + self.memoized_distance_squared[self.state[x2[0]]][ self.state[x2[1]]]
        else:
            return self.memoized_distance_squared[self.state[x1[0]]][ self.state[x1[1]] ] + self.memoized_distance_squared[self.state[x2[0]]][ self.state[x2[1]] ]

    def loop( self, iterations ):
        for i in range( iterations ):

            # comment out one approach at a time

            # first approach
            e0 = 0
            for source_partition, dest_partition in self.memoized_source_pe_and_dest_partitions:
                e0 += self.memoized_distance_squared[self.state[source_partition]][ self.state[dest_partition] ]

            # second approach
            # e1 = functools.reduce( self.do_sum, self.memoized_source_pe_and_dest_partitions )

energy = Energy()
cProfile.runctx('energy.loop(100000)',globals(), locals())