Конкретные изменения в текстовом файле (awk?)

С учетом data.awk ниже:

{
        if (matched) {
                for (i = 1; i <= NF; i++) {
                        $(i) = 30.0 - $(i)
                }
        }
        print
}
/^C/ { matched = 1 }
BEGIN { CONVFMT = "%.20f" }

Вы получаете:

$ awk -f data.awk data.txt
TITLE
1.000000000000000
10.0000000000000000    0.0000000000000000    0.0000000000000000 
0.0000000000000000   10.0000000000000000    0.0000000000000000
0.0000000000000000    0.0000000000000000   10.0000000000000000
U   U
X   X
C
29.79999999999999715783 29.79999999999999715783 29.79999999999999715783
29.70324000000000097543 29.93589999999999662350 29.84485000000000098908
29.89663000000000181444 29.66389000000000208956 29.75500999999999862666

У него, очевидно, есть проблема с точностью для ввода. Поэтому вы можете вызвать команду bc для фактических вычислений (она поддерживает произвольную точность):

{
        if (matched) {
                for (i = 1; i <= NF; i++) {
                        cmd = "echo 30.0 - " $(i) " | bc"
                        cmd | getline $(i)
                        close(cmd)
                }
        }
        print
}
/^C/ { matched = 1 }

Результат:

TITLE
1.000000000000000
10.0000000000000000    0.0000000000000000    0.0000000000000000 
0.0000000000000000   10.0000000000000000    0.0000000000000000
0.0000000000000000    0.0000000000000000   10.0000000000000000
U   U
X   X
C
29.7999999999999972 29.7999999999999972 29.7999999999999972
29.7032400000000010 29.9358999999999966 29.8448500000000010
29.8966300000000018 29.6638900000000021 29.755009999999999

Чтобы перезаписать data.txt с результатом , вам обычно нужно записать его в другой файл, а затем переименуйте его в исходный файл.

$ awk -f data.awk data.txt > data.txt.out
$ mv data.txt.out data.txt

Или используйте sponge в moreutils.

$ sudo apt-get install moreutils
$ awk -f data.awk data.txt | sponge data.txt

Использование python:

#!/usr/bin/env python2
import decimal
with open('/path/to/data.txt') as f:
    for line in f:
        if line.rstrip() == 'C':
            print line.rstrip()
            break
        else:
            print line.rstrip()
    for line in f:
        print '\t'.join(['{0:.16f}'.format(decimal.Decimal(30 - float(part))) for part in line.rstrip().split()])

Выход:

TITLE
1.000000000000000
10.0000000000000000    0.0000000000000000    0.0000000000000000
0.0000000000000000   10.0000000000000000    0.0000000000000000
0.0000000000000000    0.0000000000000000   10.0000000000000000
U   U
X   X
C
29.7999999999999972 29.7999999999999972 29.7999999999999972
29.7032400000000010 29.9358999999999966 29.8448500000000010
29.8966300000000018 29.6638900000000021 29.7550099999999986

Каждый раз, когда python читает строку файла, указатель увеличивается на единицу, чтобы указывать на в следующей строке мы используем это для чтения и печати до строки, содержащей только C. Для линий после C мы разделили линию на части на line.rstrip().split(), а затем вычитали каждую часть из 30, чтобы получить желаемый результат. Чтобы получить точность для полученного числа с плавающей запятой, мы использовали модуль decimal.

Я не могу обеспечить хорошее решение проблемы, но я попытаюсь подробно описать, в чем проблема, и я предоставлю частичное решение.

Проблема: [!d1 ]

Числа с плавающей запятой на машинах имеют ограниченную точность: короче говоря, только ограниченное подмножество чисел с плавающей запятой [на каждый порядок величины] представляется.

Числа с плавающей запятой на машинах представлены близко следуя нормированной нотации ± significand * base ^ exponent (где base = база представления, significand = любое действительное число> 0 и & lt; = база представления и где exponent = порядок величины): например, на 32-битная машина, следующая за стандартом IEEE 754, числа с плавающей запятой с одинарной точностью представлены с использованием первого бита для представления знака, следующие 8 бит для представления порядка величины и последних 23 бит для представления значения, а двойные -значные числа с плавающей запятой представлены с использованием первого бита для представления знака, следующие 11 бит для представления t порядка и последних 52 бит для представления значения (основание, всегда 2, не представлено). Для этого значение значимости числа должно быть представлено всегда с использованием 23 бит (с использованием одной точности) или с использованием 52 бит (с использованием двойной точности).

Свойство этого способа представления чисел с плавающей запятой на фиксированное число битов состоит в том, что число чисел, представляющих значение на порядок, всегда одинаковое, среднее «расстояние» между представляемыми числами с плавающей запятой с одинаковым порядком возрастает по мере увеличения порядка величины двух. [!d5 ]

Для вышеизложенного первая проблема заключается в том, что если значение значащего значения нормированной нотации с плавающей запятой не находится в ограниченном наборе представимых значений, оно округляется до ближайшего (более высокого или более низкого) значения и представляемого.

[d7 ] Говоря о числах, представленных с одинаковым порядком величины, вторая проблема заключается в том, что даже когда число с плавающей запятой представляется точно, добавление / вычитание другого [точно представляемого] числа с плавающей запятой может привести к неявно представимое число с плавающей запятой, значение которого будет округлено до ближайшего (более высокого или более низкого) значимого и представимого.

Наконец, говоря о числах, представленных с другим порядком величины, третья проблема (в основном из-за к архитектуре ЦП) заключается в том, что для того, чтобы иметь возможность выполнять дополнения / подстановки между числами с плавающей запятой, представленными с другим порядком величины, числа должны быть сначала представлены с использованием того же порядка величины; это означает, что порядок наименьшего порядка необходимо увеличить, и что (чтобы сбалансировать это) его значение необходимо сдвинуть вправо с последующей потерей количества бит, превышающего 23/252; если этого недостаточно, числа с плавающей запятой со значительной разницей по порядку величины могут привести к тому, что после добавления / вычитания точно в количестве с самым высоким абсолютным значением это для уже заявленной проблемы (недостаточно разницы, представляя значимое значение вверх / вниз до другого более высокого / более низкого представляемого значения) и все хуже, поскольку порядок величины двух чисел расходится дальше.

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

Задача :

Для вышесказанного, результаты этих awk однострочных неточны; это могло бы быть смягчено использованием двойной точности в их командах printf, но это не поддерживается.

Это уменьшится на 30, значение первые 3 пробела в каждой строке после первой строки, соответствующей C, сохраняя формат чисел. Поскольку версия awk, включенная в Ubuntu, не поддерживает редактирование на месте, вам придется либо использовать awk, либо перенаправить ее stdout в файл с помощью оператора bash > или использовать gawk (GNU awk)> = 4.10.0;

Использование awk:

awk 'NR==1, $0=="C"; $0=="C", 0 {if ($0!="C") printf "%.16f  %.16f  %.16f\n", $1-30, $2-30, $3-30}' data.txt > data_processed.txt

Использование gawk (GNU awk)> = 4.10.0

gawk -i inplace 'NR==1, $0=="C"; $0=="C", 0 {if ($0!="C") printf "%.16f  %.16f  %.16f\n", $1-30, $2-30, $3-30}' data.txt

NR==1, $0=="C";: выбор и печать всех записей между первым и первым совпадением C включительно; $0=="C", 0 {if ($0!="C") printf "%.16f %.16f %.16f\n", $1-30, $2-30, $3-30}: выбор всех записей между первым совпадением C и последним включением и печать 1-го, 2-го и 3-го полей каждой выбранной записи, не соответствующих C двойному пространству, разделенному и уменьшенному на 30, сохраняя оригинал формат номера;

Пример вывода:

~/tmp$ cat data.txt
TITLE
1.000000000000000
10.0000000000000000    0.0000000000000000    0.0000000000000000 
0.0000000000000000   10.0000000000000000    0.0000000000000000
0.0000000000000000    0.0000000000000000   10.0000000000000000
U   U
X   X
C
0.2000000000000028  0.2000000000000028  0.2000000000000028
0.2967599999999990  0.0641000000000034  0.1551499999999990
0.1033699999999982  0.3361099999999979  0.244990000000001
~/tmp$ awk 'NR==1, $0=="C"; $0=="C", 0 {if ($0!="C") printf "%.16f  %.16f  %.16f\n", $1-30, $2-30, $3-30}' data.txt
TITLE
1.000000000000000
10.0000000000000000    0.0000000000000000    0.0000000000000000 
0.0000000000000000   10.0000000000000000    0.0000000000000000
0.0000000000000000    0.0000000000000000   10.0000000000000000
U   U
X   X
C
-29.7999999999999972  -29.7999999999999972  -29.7999999999999972
-29.7032400000000010  -29.9358999999999966  -29.8448500000000010
-29.8966300000000018  -29.6638900000000021  -29.7550099999999986