Virtual concatenation with arrays - c++

Question

Suppose I have 3 double precision arrays a1[], a2[], a3[] each of length L1, L2, L3
Suppose I want to concatenate these arrays "virtually" That is I want to create a virtual
array a_virtual[] such that a_virtual = {a1[L1], a2[L2], a3[L3]} logically, though physically these arrays may not be contiguous to each other.
So if I want to access a_virtual[5] and L1=2, L2=3, L3=1 then a3[0] will be fetched. For accessing a_virtual[0], a1[0] will be fetched
How would I do this
in C
in C++ (how to do this with std::vectors in place of arrays would
also be useful)
in CUDA
I suspect if there is a way to do it, it would be the same for all the three environments, but there might be more efficient ways to do this within each environment depending on the
capabilities provided.

Answer 1

Here's a possible solution in C, using linked-list and (tail) recursion:
#include <stdio.h>
struct dblarr {
double *data;
size_t len;
struct dblarr *next;
};
double *fetch(const struct dblarr *arr, size_t index) {
if (arr == NULL) return NULL;
if (index < arr->len) return arr->data + index;
return fetch(arr->next, index - arr->len);
}
int main(void) {
double a1[2] = {1, 2};
double a2[3] = {1, 2, 3};
double a3[1] = {1};
struct dblarr x1, x2, x3;
x1.data = a1; x1.len = sizeof a1 / sizeof *a1; x1.next = &x2;
x2.data = a2; x2.len = sizeof a2 / sizeof *a2; x2.next = &x3;
x3.data = a3; x3.len = sizeof a3 / sizeof *a3; x3.next = NULL;
printf("before %f\n", *fetch(&x1, 5));
*fetch(&x1, 5) = 0.42;
printf(" after %f\n", *fetch(&x1, 5));
return 0;
}
You can "see the code running" at http://ideone.com/mY0ix.

Answer 2

How about something like the following? It's pretty hard-coded and not the best/ cleanest code, but maybe you can generalize this logic?
#include <iostream>
#include <vector>
using namespace std;
void logicalConcat(vector<int>& a1, vector<int>& a2, vector<int>& a3, int k) {
if(k > a1.size() - 1)
k -= a1.size();
else {
cout << a1[k] << endl;
return;
}
if(k > a2.size() - 1)
k -= a1.size();
else {
cout << a2[k] << endl;
return;
}
cout << a3[k] << endl;
}
Here k would be the index of the the virtual concatenation you want. We're not concatenating anything, just iterating over the vectors.

Answer 3

If the arrays need not be contiguous, then one way to do it is to convert a single index into two indices, one for an array of pointers to the real arrays, and another for the array that has the desired element.
To do this, you would create an array of pointers to those arrays:
double** arrays = {a1, a2, a3};
then an array of their lengths:
int arraysizes = { sizeof(a1) / sizeof(*a1), sizeof(a2) / sizeof(*a2), sizeof(a3) / sizeof(*a3) };
Then, given an index n, you can calculate the two indices for arrays by doing
int i1 = 0, j = 0;
while (n - arraysizes[j] >= 0)
n -= arraysizes[j++], ++i1;
And you can then index the array of pointers like this to get the actual element:
arrays[n][i2]
You could also create a wrapper class to do this arithmetic with a built in operator[].

Answer 4

Some of the others provide an answer for a basic C implementation.
Here is some sample code for a general-purpose c++ implementation of a class which creates virtual concatenated arrays without copying any of the array elements. Once created, the virtual array can be indexed like an ordinary vector (to be read or written to):
#include <vector>
#include <map>
#include <iostream>;
using namespace std;
class VirtualArray {
public:
multimap<int,double*> startIndices; // reverse map of starting index to its sub array
int size;
VirtualArray() : size(0) {}
double & operator[](int i) {
// find proper subarray in log(n) time
multimap<int,double*>::iterator iter = --startIndices.upper_bound(i);
double *subarray = iter->second;
int startIndex = iter->first;
// index into subarray
return subarray[i-startIndex];
}
void addArray(double* array, int length) {
startIndices.insert(make_pair(size, array));
size += length;
}
void addVector(vector<double> & vec) {
startIndices.insert(make_pair(size, vec.data()));
size += vec.size();
}
};
int main() {
double a1[3], a2[4], a3[6] = {1, 2, 3, 4, 5, 6};
int L1 = 3, L2 = 4, L3 = 6;
vector<double> a3vec;
a3vec.assign(a3,a3+6);
VirtualArray vArray;
vArray.addArray(a1,L1);
vArray.addArray(a2,L2);
vArray.addVector(a3vec);
cout << vArray[10];
return 0;
}