How can I generate two diferrent matrices of random numbers, under the condition that the sum of all their elements is for both the same?

I have created two different matrices of randomly generated numbers in C++:

a = new int* [IT]();
    for (int j = 0; j < IT; j++) {
        a[j] = new int[P];
        for (int p = 0; p < P; p++) {
            a[j]
 = RL.randint(0,100); // I have created the randint function in another cpp file
        }
    }
b = new int* [OT]();
    for (int m = 0; m < OT; m++) {
        b[m] = new int[P];
        for (int p = 0; p < P; p++) {
            b[m]
 = RL.randint(0, 100); 
        }
    }

Now i want to implement somehow the condition that:
∑(j,p)〖a(j,p)〗= ∑(m,p)〖b(m,p)〗

I didn't find anything that could help me in Google, only some examples of generating numbers under the condition that their sum meats a certain target (eg. sumofrandnumbs = 6). In my case I don't have a specific number that i want to meet, only the criterion that the two sums must be the same. I am thinking maybe it's easier to generate the numbers under this criterion in excel and then fetch them into my cpp file and put them into the a and b matrices. I don't know how to do that either but i have found some information online. Your help would mean a lot.Thank you very much.

Calculate the rate K = Sum_of_a/Sum_of_b.

Then, if K<=1.0 multiply this K to b else multiply 1/K to a (This selection is to keep all element values <= 100).

However, since the element type is int, some adjustments will be necessary later.
(Like re-checking the result sum and adding the shortfall at random places.)

What I would do is compute the delta between the 2 sums and then change delta values in the second array to get the same sums.

Within OPL CPLEX I would write this :

int n=5;
range r=1..n;

int ar1[i in r][j in r]=rand(101);
int ar2[i in r][j in r]=rand(101);

int sum1=sum(i,j in r) ar1[i][j];
int sum2=sum(i,j in r) ar2[i][j];

int delta=sum2-sum1;
int absdelta=ftoi(abs(delta));
int inc=-delta div absdelta;

range rabsdelta=1..absdelta;

execute
{
  writeln("sum1=",sum1);
  writeln("sum2=",sum2);
}

execute
{
  for(var i in rabsdelta)
  {
    var x=1+Opl.rand(n);
    var y=1+Opl.rand(n);
    ar2[x][y]=ar2[x][y]+inc;
  }
}

int sum1after=sum(i,j in r) ar1[i][j];
int sum2after=sum(i,j in r) ar2[i][j];

execute
{
  writeln();
  writeln("after move delta values");
  writeln();
  writeln("sum1=",sum1after);
  writeln("sum2=",sum2after);
}

which gives

sum1=1311
sum2=1559

after move delta values

sum1=1311
sum2=1311

> How can I generate two diferrent matrices of random numbers, [...]?

There are plenty of open source linear algebra libraries, but I'll just reinvent the wheel here and start writing¹ a (incomplete and barely functioning) matrix class.

#include <algorithm>
#include <iomanip>
#include <iostream>
#include <random>
#include <vector>

template< typename T >
class Matrix
{
    std::vector<T> d_;
    int rows_, cols_;
public:
    Matrix(int r, int c)
        : d_(checked_size(r) * checked_size(c))
        , rows_(r), cols_(c)
    {}
    template< typename Gen >
    // This constructor uses the passed generator to initialize the matrix values.
    Matrix(int r, int c, Gen&& gen) : Matrix(r, c)
    {
        std::generate(begin(), end(), gen);
    }

    // Other accessors are left to the reader.
    auto rows()    const noexcept { return rows_; }
    auto columns() const noexcept { return cols_; }
    auto begin() const noexcept { return d_.begin(); }
    auto begin()       noexcept { return d_.begin(); }
    auto end()   const noexcept { return d_.end(); }
    auto end()         noexcept { return d_.end(); }
private:
    auto checked_size(int s)
    {
        if ( s <= 0 ) throw std::domain_error{"Must be greater than zero"};
        return static_cast<std::size_t>(s);
    }
};

template< typename T >
auto operator<< (std::ostream& os, Matrix<T> const& m) -> std::ostream&
{
    auto width{ static_cast<int>(os.width()) };
    for( auto i{ std::begin(m) }; i != std::end(m); )
    {
        for( auto j{ i + m.columns() }; i != j; ++i )
            os << std::setw(width) << *i;
        os << '\n';
    }
    return os;
}

int main()
{
    // Initialize a random number engine based on Mersenne Twister algorithm.
    // It will be used by the distribution to generate pseudo-random numbers.
    auto eng{ []{
        std::random_device rd;
        std::seed_seq ss{ rd(), rd(), rd() };
        return std::mt19937{ ss };
    }() };
    
    auto rnd_int{ [&eng]{ 
        static std::uniform_int_distribution dist(0, 100);
        return dist(eng); 
    }};
    
    Matrix<int> a(10, 10, rnd_int);
    std::cout << std::setw(4) << a
              << "Sum: " << std::accumulate(a.begin(), a.end(), 0ll) << "\n\n";
}

Now that we have generated one matrix, we can transform it such that the sum of its elements remains constant. In the Standard Library, there's an algorithm² called std::shuffle which

> Reorders the elements in the given range [first, last) such that each possible permutation of those elements has equal probability of appearance.

I'm going to modify one of its possible implementations³, so that instead of just swapping two elements it will apply a more generic transformation.

template<class RandomIt, class URBG, class S>
void shuffle(RandomIt first, RandomIt last, URBG&& g, S&& scramble)
{
    typedef typename std::iterator_traits<RandomIt>::difference_type diff_t;
    typedef std::uniform_int_distribution<diff_t> distr_t;
    typedef typename distr_t::param_type param_t;
 
    distr_t D;
    for (diff_t i = last - first - 1; i > 0; --i)
    {
        scramble(first[i], first[D(g, param_t(0, i))]);      // <--
    }
}

The idea is that we can take any pair of elements in the matrix, change their values and, as long as their sum remains the same, the global sum won't change either.

auto noiser{ [&eng](int& a, int& b) {
    if ( &a == &b )  // <- It's ugly, but we need to avoid this case.
        return;
    auto const sum{ a + b };
    /*
        0---A-------B-------100             0--------A--------B-100
        <-----A'-------->                          <----A'------> 
    */
    std::uniform_int_distribution d(std::max(0, sum - 100), std::min(100, sum));
    a = d(eng);
    b = sum - a;
}};

Live: https://godbolt.org/z/a1f5s9v4W

^{1) https://godbolt.org/z/Ga9841v9a}
^{2) https://en.cppreference.com/w/cpp/algorithm/random_shuffle}
^{3) Version 3 (shuffle) at https://en.cppreference.com/w/cpp/algorithm/random_shuffle#Possible_implementation}

you can not implement it in one single iteration step unless you want to cheat on the output.

you have to get a matrix of random number for the first number and store the sum value at some variable then you need repeatedly generate the second matrix again and again until its sum is equal to first one and the code looks something like this

<pre>

int suma=0
a = new int* [IT]();
for (int j = 0; j &lt IT; j++) {
a[j] = new int[P];
for (int p = 0; p &lt P; p++) {
a[j]
 = RL.randint(0,100); 
suma+=a[j]
;
}
}
b = new int* [OT]();
while(true){
sumb=0
for (int m = 0; m &lt OT; m++) {
b[m] = new int[P];
for (int p = 0; p &lt P; p++) {
b[m]
 = RL.randint(0, 100); 
sumb+=b[m]
;
}
}
if(suma == sumb){
break;
}
}

</pre>

but this method is not recommend this at all if the speed is it you are looking.

this will iterate at least of few million times if p is large.

time complexity will be O((random Number Allowed Length)(OT*P))
so, O(1009) for the 3x3. this worst case.

but we can cheat this by simple technique by generating all random numbers in the second array except the last number. and find the last number by
<pre>

b[OT-1][P-1]=suma-sumb-b[Ot-1][P-1];

</pre>
the code looks something like this;

<pre>

int suma=0
a = new int* [IT]();
for (int j = 0; j &lt IT; j++) {
a[j] = new int[P];
for (int p = 0; p &lt P; p++) {
a[j]
 = RL.randint(0,100); 
suma+=a[j]
;
}
}
b = new int* [OT]();
int sumb=0
for (int m = 0; m &lt OT; m++) {
b[m] = new int[P];
for (int p = 0; p &lt P; p++) {
b[m]
 = RL.randint(0, 100); 
sumb+=b[m]
;
}
}
b[OT-1][P-1]=suma-sumb-b[Ot-1][P-1];

</pre>

now this will have a guaranteed output with single iteration regardless of the probability. but adjust some random numbers such that you always end up with positive number in the modified value.

if this helps, leaving a upvote is appreciated.