Witam
Mam taki problem :
Staram się napisać programik, który na podstawie wczytanego pliku :

oznacza krok symulacji

Wynikiem ma być tablice dla każdej z wartości w każdej symulacji : 0.5,0.48045,0.52556…itd.
Tablica taka powinna mieć wartość przykładowo dla 1 danej każdej symulacji {0.5,0.5+0,48045,0.5+0.48045+0,52556…..itd….} : żeby zczytywała po kolei z 1.1 pierwszą wartość z 2.1 pierwszą wartosć + tą poprzednią do momemtu skończenia symulacji.
I tak wszystkie wartości w pliku .txt

#1.1
0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5
#2.1
0.48045 0.37837 0.36096 0.43248 0.65979 0.51712 0.5 0.77353 0.24566
#3.1
0.52556 0.32728 0.37208 0.45111 0.62236 0.52216 0.5 0.72307 0.25144
#4.1
0.52224 0.33494 0.36821 0.44961 0.62323 0.53737 0.5 0.72748 0.24834
#5.1
0.52248 0.33424 0.36727 0.45013 0.62276 0.5352 0.5 0.72661 0.24619
#6.1
0.52284 0.3344 0.36735 0.45026 0.62244 0.53539 0.5 0.72631 0.24646
#7.1
0.52277 0.33444 0.36731 0.45025 0.62248 0.53539 0.5 0.72637 0.24642
#8.1
0.52278 0.33443 0.36731 0.45026 0.62247 0.53538 0.5 0.72636 0.24642
#9.1
0.52278 0.33443 0.36731 0.45025 0.62247 0.53538 0.5 0.72636 0.24642
#10.1
0.52278 0.33443 0.36731 0.45025 0.62247 0.53538 0.5 0.72636 0.24642

Póki co mam tylko kod do dodawania floatóworaz usuwania #

#include <iostream>
#include <functional>
#include <numeric>
#include <vector>
using namespace std;
int main()
{
  vector <float> data= { 0.1, 0.2, 0.3, 0.4, 0.5 };
std::partial_sum(data.begin(), data.end(), data.begin());

    for (unsigned i = 0; i < data.size(); ++i)
    cout << "Zliczanie[" << i << "]: " << data[i] << "\n";
}

string out_pats;
    while ( !netfile.atEnd() )
    {
        QString line(netfile.readLine());
        if(line.contains("#"))
        {
            out_pats.append("#");//line);
            break;
        }
        raw.append(line);
    }

Jak zrobić by tak zliczał jak wcześniej napisałem?

Chodzi o to że mamy plik z rozszerzeniem .res w którym są dane. #1.1, #2.1,#3.1..... itd to jest krok symulacji zadaniem programu jest stworzenie tylu tablic ile jest danych w kroku : w pliku jest to 100 zmiennych w kroku.Takblica ta brała by po każdej pierwszej zmiennej z kroku i je dodawała np {0,5, 0,5+0.48045,0,5+0.48045+0.52556 itd do końca kroków

Rozpisz na kratce kolejne kroki.

Z twojego opisu wynika, że chcesz, aby każda kolejna komórka w tablicy miała wartość o wczytaną wartość wyższą wartość, a na koniec do każdego elementu tablicy dodać 0.5.

Mamy przykład :
#1.1
0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5
#2.1
0.48045 0.37837 0.36096 0.43248 0.65979 0.51712 0.5 0.77353 0.24566
#3.1
0.52556 0.32728 0.37208 0.45111 0.62236 0.52216 0.5 0.72307 0.25144

tablica1={0.5,0.5+0.48045,0.5+0.48045+0.52556}
tablica2={0.5,0.5+0.37837,0.5+0.37837+0.32728}
tablica3={0.5,0.5+0.36096,0.5+0.36096+0.37208)
itd... do końca wartości

Załaduj wszystkie wiersze do osobnych tablic i zliczaj kolumnami jak w tablicy dwuwymiarowej.

Chodzi Ci o takie działanie:

#include <iostream>
#include <iomanip>

const size_t N = 5;

int in[N][N];
int out[N][N];

void show(const int array[N][N]);

int main() {

  for (size_t r = 0; r < N; ++r) {
    for (size_t c = 0; c < N; ++c) {
      in[r][c] = c + N * r;
    }
  }

  show(in);

  for (size_t c = 0; c < N; ++c) {
    out[c][0] = in[0][c];
  }

  for (size_t r = 0; r < N; ++r) {
    for (size_t c = 1; c < N; ++c) {
      out[r][c] = out[r][c - 1] + in[c][r];
    }
  }

  show(out);

  return 0;
}

void show(const int array[N][N]) {
  for (size_t r = 0; r < N; ++r) {
    for (size_t c = 0; c < N; ++c) {
      std::cout << std::setw(2) << array[r][c] << " ";
    }
    std::cout << std::endl;
  }
  std::cout << std::endl;
}

 0  1  2  3  4 
 5  6  7  8  9 
10 11 12 13 14 
15 16 17 18 19 
20 21 22 23 24 

 0  5 15 30 50 
 1  7 18 34 55 
 2  9 21 38 60 
 3 11 24 42 65 
 4 13 27 46 70 

Jakiś przykład na tych wierszach ? Bo troszkę nie rozumiem :)

Hasło w gugiel 'tablica dwuwymiarowa' i wynik http://www.algorytm.edu.pl/tablice-w-c/tablice-wielowymiarowe.html

Można jeszcze wykorzystać Boost i bibliotekę uBLAS: Basic Linear Algebra Library

A tu przykład:

#include <iostream>
#include <random>
#include <chrono>
#include <boost/numeric/ublas/matrix.hpp>
#include <boost/numeric/ublas/io.hpp>

using namespace boost::numeric::ublas;

int main() {
  unsigned seed = std::chrono::system_clock::now().time_since_epoch().count();

  std::minstd_rand0 generator (seed);

  // Na typie int łatwiej zobaczyć, czy działa
  matrix<int> m(4, 5);

  for (size_t i = 0; i < m.size1(); ++i) {
    for (size_t j = 0; j < m.size2(); ++j) {
      m(i, j) = generator() % 20;
    }
  }

  for (size_t i = 0; i < m.size1(); ++i) {
    for (size_t j = 0; j < m.size2(); ++j) {
      std::cout << m(i, j) << " ";
    }
    std::cout << std::endl;
  }
  std::cout << std::endl;

  // Tu jest główna logika twojej operacji
  m = trans(m);

  for (size_t i = 0; i < m.size1(); ++i) {
    for (size_t j = 1; j < m.size2(); ++j) {
      m(i, j) = m(i, j) + m(i, j - 1);
    }
  }
  // Tu jest koniec

  for (size_t i = 0; i < m.size1(); ++i) {
    for (size_t j = 0; j < m.size2(); ++j) {
      std::cout << m(i, j) << " ";
    }
    std::cout << std::endl;
  }

  return 0;
}

Dobra zrozumiałem...... w moim przypadku to ma być coś w stylu 100x100

https://wandbox.org/permlink/7e0U219ZWsSXvoNV