Dotaz: bash: porovnanie des. cisel

[oron]

a=2.56
b=3.89

potrebujem spravit podmienku

if $a < $b; then
  echo "a < b"
fi

prosim vas ako ? najeko sa stale mocem dokola a nejde mi to ...?
dik

Odpovědi

[Tomík Pařízek]

man bash:

"-gt" > "-lt" <

atd...

[oron]

porovnat cele cisla samozrejme viem,
problem mam s des.cislom .... ?

[Yeti]

Bash neumí porovnávat desetinná čísla. Nehledě na to, že < je v shellu přesměrování. Použij zsh, awk, perl, ...

[oron]

ano ... viem ze bash nevie robit s des. cislom ... skusam to pomocou bc, ale toto sa mi zda trocha divoke

if [ $(bc << EOF
$a < $b
EOF
) -eq 1 ]; then
   echo "a < b"
else
   echo "a > b" 
fi

[Hynek (Pichi) Vychodil]

hmm, a co je na tom divného. Když holt nechceš použít něco pořádného, tak se nediv. Krom toho tvrďáci by použili dc.

[ $(dc <<<"[1pq]sa$a $b>a0p") -eq 1 ] &&
  echo "a < b" ||
  echo "a > b"

[Yeti]

Tvrďák použije sort ;-)

function rnle() {
  test `echo -e "$1\\n$2" | sort -g | head -n 1` = $1
}
function rnge() {
  test `echo -e "$1\\n$2" | sort -g | head -n 1` = $2
}

[Hynek (Pichi) Vychodil]

No mě to přijde proti dc moc easy, ale musím uznat, že je to drsnější co do plýtvání systémovými prostředky a na to mě moc neužije. Krom toho jsem se po dlouhé době donutil přečíst man dc a možnosti tohoto nástroje mě nadchly, takže odpříště všechno nepíšu v bashi, ale v dc

[Hynek (Pichi) Vychodil]

A vůbec. Ještě jednou se snížím k bashi.

rnlt() {
  if [ ${1:0:1} == '-' -a ${2:0:1} == '-' ]
  then
    rngt ${1:1} ${2:1}
    return $?
  fi
  IFS='.'
  a=($1)
  b=($2)
  [ ${a[0]} -lt ${b[0]} ] && return 0
  [ ${a[0]} -gt ${b[0]} ] && return 1
  i=0
  while :
  do
    [ -z "${a[1]:$i:1}" -a -n "${b[1]:$i:1}" ] && return 0
    [ -z "${b[1]:$i:1}" ] && return 1
    [ ${a[1]:$i:1} -lt ${b[1]:$i:1} ] && return 0
    let i++
  done
}
rngt() {
  if [ ${1:0:1} == '-' -a ${2:0:1} == '-' ]
  then
    rnlt ${1:1} ${2:1}
    return $?
  fi
  IFS='.'
  a=($1)
  b=($2)
  [ ${a[0]} -gt ${b[0]} ] && return 0
  [ ${a[0]} -lt ${b[0]} ] && return 1
  i=0
  while :
  do
    [ -n "${a[1]:$i:1}" -a -z "${b[1]:$i:1}" ] && return 0
    [ -z "${a[1]:$i:1}" ] && return 1
    [ ${a[1]:$i:1} -gt ${b[1]:$i:1} ] && return 0
    let i++
  done
}

Teda zatím to není úplně blbuvzdorné a používá se to.

rnlt $a $b && echo 'a < b' || echo 'a >= b'

[unchallenger]

Dělám snad někde chybu -- kromě toho, že neparsuji semilogaritmický tvar -- když to porovnávám jen

function rnle() {
  [ ${1/.*} -lt ${2/.*} ] && return 0
  [ ${1/.*} -gt ${2/.*} ] && return 1
  if [ ${1:0:1} = '-' ]; then
    [ ! ${1#*.}0 \> ${2#*.}0 ]
  else
    [ ! ${2#*.}0 \> ${1#*.}0 ]
  fi
}

[Hynek (Pichi) Vychodil]

Děláš:

$ rnle 3.45 3.345 && echo OK
OK
$ rnle 3 3.345 && echo OK
$

Nicméně, když na to teď s odstupem koukám, tak je to fakt hnus, co takhle:

rnle() {
  IFS='.'
  a=($1)
  b=($2)
  [ $a -lt $b ] && return 0
  [ $a -gt $b ] && return 1
  if [ ${a:0:1} == '-' ]
  then
    a[0]=${b[1]}
    b=${a[1]}
  else
    a=${a[1]}
    b=${b[1]}
  fi
  for((i=${#a};i<${#b};i++)); do a=${a}0; done
  for((i=${#b};i<${#a};i++)); do b=${b}0; done
  [ $a -ge $b ] && return 1
  return 0
}

[unchallenger]

V tom problém není, protože > porovnává lexikograficky. Jen jsem zaměnil větve té podmínky

function rnle() {
  [ ${1/.*} -lt ${2/.*} ] && return 0
  [ ${1/.*} -gt ${2/.*} ] && return 1
  if [ ${1:0:1} = '-' ]; then
    [ ! ${2#*.}0 \> ${1#*.}0 ]
  else
    [ ! ${1#*.}0 \> ${2#*.}0 ]
  fi
}

[Hynek (Pichi) Vychodil]

Musím uznat, že je to elegantní

rnlt() {
  if [ ${1/.*} -ne ${2/.*} ]
  then [ ${1/.*} -lt ${2/.*} ]
  elif [ ${1:0:1} = '-' ]
  then [ ${1#*.}0 \> ${2#*.}0 ]
  else [ ${2#*.}0 \> ${1#*.}0 ]
fi
}

Tak dnešní kontest jsi vyhrál

[Ja]

Ja to mam podobne, i kdyz asi trochu prasacky ...

function rnlt()
{
        celacast_1=`echo $1|cut -d. -f 1`;
        descast_1=`echo $1|cut -d. -f 2`;
        celacast_2=`echo $2|cut -d. -f 1`;
        descast_2=`echo $2|cut -d. -f 2`;
        if [ $celacast_1 -eq $celacast_2 ]
        then
                if [ $celacast_1 -lt 0 ]
                then
                        descast_1=`expr -1 \* $descast_1`;
                        descast_2=`expr -1 \* $descast_2`;
                fi
                [ $descast_1 -lt $descast_2 ]&& return 0;
                return 1;
        else
                [ $celacast_1 -lt $celacast_2 ]&& return 0;
                return 1;
        fi
}

[Hynek (Pichi) Vychodil]

Stejnej problém jako Yeti, nestejně dlouhé desetiné části selžou. Nicméně, naučit se používat konstrukce typu ${variable#pattern}, ${variable%pattern} a používat IFS by ušetřilo hodně zbytečných subprocesů.

[Hynek (Pichi) Vychodil]

A to nemluvím o těch zbytečnejch echo.