Multiplying elements in custom lists in Haskell - haskell

Question

I am trying to implement a custom multiplication operation for my custom list data type in Haskell that uses an Int and [Int].
Int is used to reduce integers by modulus division I will refer to as d.
[Int] represents the content of the list
Let's say a and b are two lists that have the same d.
The length of a is w and the length of b is v
The c = a*b is:
c[k] = a[0] * b[k] + a[1] * b[k - 1] + a[2] * b[k - 2] + · · · + a[k] * b[0]
At the end, c[k] is reduced by mod d.
The length of c = w + v - 1
Meaning the index k in c[k] can be larger than the lengths of w and v.
To deal with this I concatenate a list of 0 elements for indices outside the bounds of the original list.
To clarify:
c[0] = (a[0] * b[0]) % d
c[1] = (a[0] * b[1] + a[1] * b[0]) % d
c[2] = (a[0] * b[2] + a[1] * b[1] + a[2] * b[0]) % d
.
.
.
c[w + v - 1]
For example, a = [3,2,4] and b = [7,9,7,2], both have d = 31.
In the code when they are being multiplied they are [3,2,4,0,0,0] and [7,9,7,2,0,0]
In this example, c = a * b = [21, 10, 5, 25, 1, 8]
This is my code:
module Custom where
data CustomList = CustomList Int [Int]
instance Num CustomList where
(CustomList a1 b1) * (CustomList a2 b2) =
if length b1 >= 1 && length b2 >= 1 then do
let llen = (length b1) + (length b2) - 1
--concatenating a list of 0 elements for indices outside the bounds of the original list.
let sub_b1 = llen - (length b1)
let sub_b2 = llen - (length b2)
let zeros_b1 = map (0*) [1..sub_b1]
let zeros_b2 = map (0*) [1..sub_b2]
--matching list lengths
let new_b1 = b1++zeros_b1
let new_b2 = b2++zeros_b2
--trying to mimic a nested for loop
let ans = [ (new_b1 !! x) * (new_b2 !! y) | x <- [0..llen-1], y <- (reverse [0..x]) ]
CustomList (a1) (map (`mod` (a1)) ans)
else do
0
instance Show CustomList where
show (CustomList a b) = "output: " ++ (show b) ++ "\nlength: " ++ (show a)
Output:
*Custom> let a = CustomList 31 [3,2,4]
*Custom> let b = CustomList 31 [7,9,7,2]
Incorrect (What I get)
*Custom> a * b
output: [21,18,14,28,5,28,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
length: 31
Correct (What I should get)
output: [21, 10, 5, 25, 1, 8]
length: 6
I realize issues in my logic:
The x counter, I need to start from a[0] and end at a[k] for all c[k] calculations but I am starting at a[x].
Answers are not being summed together. For instance, instead of obtaining c[1] = a[0] * b[1] + a[1] * b[0], I obtain c[1] = a[0] * b[1] & c[2] = a[1] * b[0]
I am not sure how to fix it, I have been trying and end up just creating new problems by trying to do.
I am a newbie at Haskell so I would prefer a simple readable way of solving this problem over the more "Haskell" way of doing it.
But any help is appreciated, thanks in advance.

Answer 1

Nice and simple:
data CustomList = CustomList Int [Int] deriving(Show)
instance Num CustomList where
CustomList a1 b1 * CustomList a2 b2 = CustomList a1 (map (`mod` a1) ans)
where ans = map getAnsElem [1..length b1 + length b2 - 1]
getAnsElem k = sum $ zipWith (*) (withLength k b1) (reverse $ withLength k b2)
withLength n xs = take n (xs ++ repeat 0)
Testing it:
λ> CustomList 31 [3,2,4] * CustomList 31 [7,9,7,2]
CustomList 31 [21,10,5,25,1,8]
Explanation:
withLength takes a list and makes it a given length, either by truncating it if it's too long, or padding with zeros if it's too short
zipWith takes 2 lists and goes over them in parallel, using the given function to combine the elements
One reason your approach with a list comprehension failed is because [f x y | x <- xs, y <- ys] takes the Cartesian product of xs and ys instead of zipping them. If you wanted to use a list comprehension instead, you could, but you'd need the ParallelListComp extension, in which case you'd have this:
getAnsElem k = sum [x * y | x <- withLength k b1 | y <- reverse $ withLength k b2]
Note the second | instead of a ,: this is what denotes zipping.