Comment pourrais-je faire quelque chose comme:
ceiling(N/500)
N représentant un nombre.
Mais dans un script linux Bash
Appelez un langage de script avec une fonction ceil. $NUMBER
:
python -c "from math import ceil; print ceil($NUMBER/500.0)"
ou
Perl -w -e "use POSIX; print ceil($NUMBER/500.0), qq{\n}"
Pourquoi utiliser des langages de script externes? Vous obtenez la parole par défaut. Pour avoir ceil, fais
$ divide=8; by=3; let result=($divide+$by-1)/$by; echo $result
3
$ divide=9; by=3; let result=($divide+$by-1)/$by; echo $result
3
$ divide=10; by=3; let result=($divide+$by-1)/$by; echo $result
4
$ divide=11; by=3; let result=($divide+$by-1)/$by; echo $result
4
$ divide=12; by=3; let result=($divide+$by-1)/$by; echo $result
4
$ divide=13; by=3; let result=($divide+$by-1)/$by; echo $result
5
....
Pour prendre en compte les nombres négatifs, vous pouvez le renforcer un peu. Des moyens probablement plus propres, mais pour commencer
$ divide=-10; by=10; neg=; if [ $divide -lt 0 ]; then let divide=-$divide; neg=1; fi; let result=($divide+$by-1)/$by; if [ $neg ]; then let result=-$result; fi; echo $result
-1
$ divide=10; by=10; neg=; if [ $divide -lt 0 ]; then let divide=-$divide; neg=1; fi; let result=($divide+$by-1)/$by; if [ $neg ]; then let result=-$result; fi; echo $result
1
Voici une solution utilisant bc (qui devrait être installée un peu partout):
ceiling_divide() {
ceiling_result=`echo "($1 + $2 - 1)/$2" | bc`
}
Voici un autre purement en Bash:
# Call it with two numbers.
# It has no error checking.
# It places the result in a global since return() will sometimes truncate at 255.
# Short form from comments (thanks: Jonathan Leffler)
ceiling_divide() {
ceiling_result=$((($1+$2-1)/$2))
}
# Long drawn out form.
ceiling_divide() {
# Normal integer divide.
ceiling_result=$(($1/$2))
# If there is any remainder...
if [ $(($1%$2)) -gt 0 ]; then
# rount up to the next integer
ceiling_result=$((ceiling_result + 1))
fi
# debugging
# echo $ceiling_result
}
Vous pouvez utiliser awk
#!/bin/bash
number="$1"
divisor="$2"
ceiling() {
awk -vnumber="$number" -vdiv="$divisor" '
function ceiling(x){return x%1 ? int(x)+1 : x}
BEGIN{ print ceiling(number/div) }'
}
ceiling
sortie
$ ./Shell.sh 1.234 500
1
Ou si vous avez le choix, vous pouvez utiliser un meilleur shell que Fait une virgule flottante, par exemple Zsh
integer ceiling_result
ceiling_divide() {
ceiling_result=$(($1/$2))
echo $((ceiling_result+1))
}
ceiling_divide 1.234 500
Mathématiquement, la fonction de plafond peut être définie avec sol, plafond (x) = -floor (-x). Et, sol est la valeur par défaut lors de la conversion d'un flottant positif en entier.
if [ $N -gt 0 ]; then expr 1 - $(expr $(expr 1 - $N) / 500); else expr $N / 500; fi
Réf. https://en.wikipedia.org/wiki/Floor_and_ceiling_functions
En développant un peu la excellente réponse de Kalle , voici l'algorithme bien emballé dans une fonction:
ceildiv() {
local num=$1
local div=$2
echo $(( (num + div - 1) / div ))
}
ou comme one-liner:
ceildiv(){ echo $((($1+$2-1)/$2)); }
Si vous voulez avoir du chic, vous pouvez utiliser une version plus robuste qui valide les entrées pour vérifier si elles sont numériques, gère également les nombres négatifs:
ceildiv() {
local num=${1:-0}
local div=${2:-1}
if ! ((div)); then
return 1
fi
if ((num >= 0)); then
echo $(( (num + div - 1) / div ))
else
echo $(( -(-num + div - 1) / div ))
fi
}
Cela utilise un "faux" plafond pour les nombres négatifs, au plus haut entier absolu, c'est-à-dire -10/3 = -4 et pas -3 comme il se doit, comme -3> -4. Si vous voulez un "vrai" ceil, utilisez plutôt $(( num / div ))
après la else
Et puis l'utiliser comme:
$ ceildiv 10 3 4 $ ceildiv 501 500 2 $ ceildiv 0 3 ceildiv -10 3 - 4
Floor () {
DIVIDEND=${1}
DIVISOR=${2}
RESULT=$(( ( ${DIVIDEND} - ( ${DIVIDEND} % ${DIVISOR}) )/${DIVISOR} ))
echo ${RESULT}
}
R=$( Floor 8 3 )
echo ${R}
Ceiling () {
DIVIDEND=${1}
DIVISOR=${2}
$(( ( ( ${DIVIDEND} - ( ${DIVIDEND} % ${DIVISOR}) )/${DIVISOR} ) + 1 ))
echo ${RESULT}
}
R=$( Ceiling 8 3 )
echo ${R}
En utilisant le magnifique 'printf' 1 arrondira au prochain entier
printf %.0f $float
or
printf %.0f `your calculation formula`
or
printf %.0f $(your calculation formula)
C'est une solution simple utilisant Awk:
Si vous voulez le plafond de ($ a/$ b) utilisez
echo "$a $b" | awk '{print int( ($1/$2) + 1 )}'
et l'utilisation du sol
echo "$a $b" | awk '{print int($1/$2)}'
Notez que je répète simplement le dividende '$ a' en tant que premier champ de la ligne à afficher et le diviseur '$ b' en tant que second.
Cette fonction n’ajoute pas 1 si la division renvoie un nombre non flottant.
function ceiling {
DIVIDEND=${1}
DIVISOR=${2}
if [ $(( DIVIDEND % DIVISOR )) -gt 0 ]; then
RESULT=$(( ( ( $DIVIDEND - ( $DIVIDEND % $DIVISOR ) ) / $DIVISOR ) + 1 ))
else
RESULT=$(( $DIVIDEND / $DIVISOR ))
fi
echo $RESULT
}
Utilisez-le comme ceci:
echo $( ceiling 100 33 )
> 4
Sans spécifier aucune fonction, nous pouvons utiliser le script awk suivant:
echo x y | awk '{ r=$1 % $2; q=$1/y; if (r != 0) q=int(q+1); print q}'
Pas sûr que celui-ci reçoive une erreur logique ou non. Corrigez s'il vous plaît.
Une logique plus concise d'Awk
awk '
function ceil(ip) {
print ip%1 ? int(ip)+1 : ip
}
BEGIN {
ceil(1000/500)
ceil(1001/500)
}
'
Résultat
2 3