How to measure distance between two data in vhdl - vhdl

Question

Calculate the distance between the position of each element in a list1 and the position of the same element in list2 then find the normalized distance in vhdl
First, we will make mem1 (consist of addresses for every data input) i.e address from 1,2,3,4.... to end of the mem1 data input,ok
mem2 (consist of addresses for every data input ) i.e address from 1,2,3,4.... t0 end of the mem2 data input,ok
Check if any of the data input from mem1 = any data input from mem2 .
I.e. The position of each element in mem1 and the position of the same element in mem2
So the address to the same element will be different in the two mem
The address difference will be the distance measure.
I.e searching for similarity, the compute the distance between list1 and list2
How I can do this in vhdl code???
Any help please???

Answer 1

Your approach sounds logical. I would design a single entity that instantiated a piece of memory. The input would be the data that you are looking for. The output would be the location of the data, and a signal indicating if the data was found or not. It would take a number of clock cycles to read out all of the data from the memory. The number of clock cycles would be equal to the depth of the memory. So if you have 10 data words in your memory, it would take 10 clocks to read through all of the words.
There are corner cases that you should consider... what if the data word is in the memory twice? Is the data stored in the memory in sequential order?
Once you've figured all of this out, instantiate two of these components inside a higher level file. This file does the calculation of the distance between the two data locations.
This is just how I would tackle it conceptually. Good luck.

Answer 2

i make a code as your suggestion rick, but i have the same problem ,what is the mistake Type of distances is incompatible with type of -
library IEEE;
use IEEE.STD_LOGIC_1164.all;
package samples is
type sample is array( 0 to 255) of std_logic_vector (0 to 7);
end samples;
entity measure is
port(
clk:std_logic;
A1: in sample;
A2: in sample;
distance: out sample);
end measure;
architecture Behavioral of measure is
signal d: sample ;
function distances(A1, A2: sample) return sample is
variable distances: sample;
begin
for i in A1'range loop
for j in A2'range loop
if (A1(i) = A2(j)) then
distances := (j - i);
end if;
end loop;
end loop;
return distances;
end;
end behavioral;

Answer 3

If I understand correctly, you want to produce an array containing the distances from each element in array_1 to the element holding the same value in array_2.
If so, here's a first stab at a possible solution:
function individual_distances(vector_1, vector_2: integer_vector) return integer_vector is
variable distances: integer_vector(vector_1'range);
begin
for i in vector_1'range loop
for j in vector_2'range loop
if (vector_1(i) = vector_2(j)) then
distances(i) := j - i;
end if;
end loop;
end loop;
return distances;
end;
Here's a sample output for a few random arrays:
individual_distances( (1, 2, 3, 4, 5), (5, 4, 3, 2, 1) ); --> (4, 2, 0, -2, -4)
individual_distances( (1, 2, 3, 4), (4, 3, 2, 1) ); --> (3, 1, -1, -3)
individual_distances( (1, 2, 3), (1, 2, 3) ); --> (0, 0, 0)
As Martin Thompson noted, whether this solution is usable in your case depends on your performance goals and the size of the lists. In practice, this could work for small to medium-sized lists. If your lists are large, you should study architectural choices. For instance, a fully serialized version of the algorithm would take N^2 clock cycles. The example below takes 64 cycles to compute the distances between two arrays with 8 elements each:
process (clock, reset) is
variable i, j: integer range 0 to 7;
begin
if reset then
i := 0;
j := 0;
distances <= (others => 0);
elsif rising_edge(clock) then
if (vector_1(i) = vector_2(j)) then
distances(i) <= abs(j - i);
end if;
if i < 7 then
i := i + 1;
else
i := 0;
j := (j + 1) mod 8;
end if;
end if;
end process;
Other intermediate solutions exist, such as serializing only the outer loop. If you need performance, you could also consider pipelining.
The above code is synthesizable, just remember to constrain the ranges as per your design requirements.