Чтение определенных данных в C ++ из файла AMPL .dat

Я пытаюсь прочитать файл .dat в C ++, который содержит данные в синтаксисе AMPL (показано ниже). Пожалуйста, сообщите, если возможно игнорировать наборы и читать только необходимые матрицы параметров в массивы C ++.
Например, я хочу прочитать ORCT, H, T, D, TO, RT, TLCT, P, V, E, NM, A, но игнорирую все остальное. На данный момент я могу читать файл, но не могу найти информацию о прочтении определенных разделов кода. Любая помощь приветствуется. Благодарю.

      # AMPL code in dat file #set L :=  1 2 3 4 5 6 7 8 9 10 11 12;

set O[1] := 1 2 3 4 5 ;
set O[2] := 6 7 8 9  ;
set O[3] := 10 11 12 13 14 ;

set O1[1] := 1 2 3 4 ;
set O1[2] := 6 7 8 ;
set O1[3] := 10 11 12 13 ;

set G := 1 ;

set SP[1] := 1 2 3 4 5 6 7 8 ;
set S[1] := 1 2 3 4 5 6 7 8 9 ;

param: R: Or:=
1 5
2 4
3 5 ;

param ORCT :=
1 1   0
1 2   1.8
1 3   4.7
2 1   4.8
2 2   0
2 3   3.9
3 1   3.2
3 2   2.1
3 3   0
;

param H :=
1  2
2  2
3  1
4  2
5  3
6  3
7  2
8  2
9  2
10  2
11  4
12  3
;

param T :=
1  2915
2  2450
3  2046
4  2622
5  2241
6  2609
7  2199
8  2318
9  2385
10  2739
11  2654
12  2266
;

param D :=
1  8
2  9
3  9
;

param TO :=
1 1    2.4
1 2    3
1 3    2
1 4    2
1 5    1
2 6    2
2 7    1.1
2 8    1.5
2 9    2.3
3 10   2.1
3 11   4.9
3 12   3.4
3 13   1.2
3 14   2.6
;

param RT :=
1 1    1.8
1 2    1.4
1 3    1.7
1 4    1.6
1 5    1.4
2 6    1.2
2 7    1.7
2 8    1.4
2 9    1.2
3 10   2
3 11   1.1
3 12   1.2
3 13   1.2
3 14   1.2
;

param TLCT:= [1,*,1,*]
:    1      2      3      4      5      :=
1   0      3.95   3.84   6.33   3.5
2   5.16   0      2.17   2.33   4.46
3   6.88   4.33   0      4.2    2.26
4   3.28   6.48   2.07   0      6.09
5   2.76   5.43   5.9    3.23   0

[1,*,2,*]
:    6      7      8      9      :=
1   2.94   3.07   6.02   3.46
2   3.22   6      2.14   3.5
3   5.57   3.63   6.07   3
4   2.4    3.29   6.2    2.4
5   6.92   4.7    3.26   3.57

[1,*,3,*]
:    10     11     12     13     14     :=
1   3.9    2.22   5.94   5.22   5.09
2   6.51   2.16   6.33   3.06   4.85
3   3.95   3.62   3.8    5.67   6.25
4   4.58   5.78   6.38   4.55   5.42
5   4.94   2.53   6.37   2.12   5.51

[2,*,1,*]
:    1      2      3      4      5      :=
6   3.48   4.93   3.9    3.71   6.58
7   6.3    5.65   5.49   3.8    2.42
8   5.93   6.27   4.75   3.85   2.88
9   2.66   5.44   2.1    3.4    6.85

[2,*,2,*]
:    6      7      8      9      :=
6   0      3.34   5.65   4.28
7   2.16   0      6.69   6.32
8   2.86   6.44   0      5.26
9   4.58   6.3    2.07   0

[2,*,3,*]
:    10     11     12     13     14     :=
6   3.93   4.39   4.25   5.55   2.04
7   4.91   6.82   6.93   2.95   3.58
8   4.14   4.85   2.44   6.74   5.43
9   5.53   5.04   5.52   3.7    2.76

[3,*,1,*]
:     1      2      3      4      5      :=
10   5.84   2.56   4.75   2.74   6.63
11   6.42   5.31   6.79   6.51   5.8
12   4.78   4.08   5.92   5.72   3.83
13   6.96   2.58   3.92   3.28   3.07
14   3.22   3.47   4.77   3.67   6.51

[3,*,2,*]
:     6      7      8      9      :=
10   3.54   4.85   6.03   6.25
11   3.3    6.73   5.37   5.14
12   6.34   2.4    4.71   6.36
13   3.41   6.83   6.4    5.66
14   3.07   6.93   5.96   3.19

[3,*,3,*]
:     10     11     12     13     14     :=
10   0      5.44   6.96   6.24   2.88
11   3.57   0      2.53   3.81   4.51
12   3.92   4.3    0      6.68   2.24
13   5.56   4.32   4      0      2.93
14   3.86   5.05   6.45   6.56   0
;

param P:= [1,*,*] (tr)
:    1   2   3   4   5    :=
1    0   0   0   0   0
2    0   0   0   0   0
3    1   0   0   0   0
4    0   0   0   0   0
5    0   0   0   1   0
6    0   0   0   0   0
7    0   0   0   0   0
8    0   0   1   0   0
9    0   0   0   0   0
10   0   1   0   0   1
11   0   0   0   0   0
12   0   0   0   0   0

[2,*,*] (tr)
:    6   7   8   9    :=
1    0   0   0   0
2    0   1   0   0
3    0   0   1   1
4    0   0   0   0
5    0   0   0   0
6    0   0   0   0
7    0   0   0   0
8    0   0   0   0
9    0   0   0   0
10   0   0   0   0
11   1   0   0   0
12   0   0   0   0

[3,*,*] (tr)
:   10  11  12  13  14    :=
1    0   0   0   0   0
2    0   0   0   0   0
3    0   0   0   0   0
4    0   0   0   1   0
5    0   0   0   0   0
6    0   0   0   0   0
7    0   0   1   0   0
8    0   0   0   0   0
9    1   0   0   0   0
10   0   0   0   0   1
11   0   1   0   0   0
12   0   0   0   0   0
;

let Orf[1] := 1 ;
let Orf[2] := 6 ;
let Orf[3] := 10 ;

let Orl[1] := 5 ;
let Orl[2] := 9 ;
let Orl[3] := 14 ;

let Z[1,1] := 1 ;
let Z[2,1] := 1 ;

let i[1,2] := 1;

let V := 7;

let E := 347;

let NM[1] := 4 ;

let A := 67 ;

1

Решение

В общем, вы не можете правильно интерпретировать файл данных AMPL, не глядя на файл модели, потому что первый не является автономным. По крайней мере, вам нужно знать размеры всех наборов, включая индексный набор каждого параметра. Например, следующий оператор данных AMPL

param P := 1 2 3 4 5 6;

может интерпретироваться по-разному в зависимости от размера набора индексации P, Если размер равен 1, как в param P{{1,3,5}}; тогда он представляет данные P[1] = 2, P[3] = 4, P[5] = 6, Если размер равен 2, как в param P{{(1, 2), (4, 5)}}; тогда он представляет данные P[1, 2] = 3, P[4, 5] = 6,

Тем не менее, вы можете читать данные параметров, если форматирование согласовано и каждая строка многомерного параметра содержит ключевые значения, за которыми следует одно значение данных. Например,

param ORCT :=
1 1   0
...

вторая строка вышеуказанного оператора данных представляет ORCT[1, 1] = 0 при этом условии.

Кстати, ваш файл представляет собой комбинацию данных AMPL и сценария, что еще более усложняет ситуацию. Поэтому я рекомендую использовать AMPL для чтения как модели, так и данных и экспортировать их в другой формат, например CVS, который может быть автономным и легко читаемым из C ++.

Вы можете получить бесплатную «студенческую» версию AMPL от AMPL страница загрузки. Бесплатная версия ограничивает количество переменных и ограничений, которые она может обработать, но это не имеет значения в вашем случае, так как вам нужно только читать и записывать данные.

0

Другие решения

Других решений пока нет …