#!/bin/csh
#######################################################################################################################################
# #
# G E N E R A T I O N D E L A T A B L E D E M U L T I P L I C A T I O N #
# D ' U N A U T O M A T E C E L L U L A I R E M O N O D I M E N S I O N N E L B I N A I R E : #
# #
# #
# Utilisation : #
# #
# $xci/AutoC_1DB.01$Z <TableMultiplication> "<regle1> ... <regle8>" [<EditerRegles> [<RendreContinu> [<Multiple>]]] #
# $xci/AutoC_1DB.01$Z <TableMultiplication> <CodeDecimalRegle> [<EditerRegles> [<RendreContinu> [<Multiple>]]] #
# #
# #
# Author of '$xci/AutoC_1DB.01$Z' : #
# #
# Jean-Francois Colonna (LACTAMME, 20021005160000). #
# #
#######################################################################################################################################
set TableMultiplication=$1
set Regles=($2)
set EditerRegles=$3
set RendreContinu=$4
# Parametre introduit le 20081122174922... #
set Multiple=$5
# Parametre introduit le 20081126144027 et n'ayant de sens que si '$RendreContinu==$EXIST'... #
setArgum EditerRegles $NEXIST
setArgum RendreContinu $NEXIST
setArgum Multiple 1
XYmaxNe $NOIR $BLANC $NOIR $BLANC
# Dimensionnement de l'album a generer en {X,Y}. #
$xci/AutoC_1DQ.01$Z "$xci/init$X n=$NOIR R=$TableMultiplication.%04d $formatI"
# Initialisation a '$NOIR' de la table de multiplication (le 20021005190511 a ete introduite #
# l'utilisation de '$xci/AutoC_1DQ.01$Z', le 20021023161522 '$TableMultiplication', son #
# premier Argument ayant ete supprime car ne servant a rien...). #
source $xci/AutoC_NDB$vv$Y
# Definitions utiles a la definition d'un automate cellulaire binaire. #
if ($#Regles == 1) then
# La possibilite d'introduire le numero decimal du jeu de regles, plutot que ce jeu lui-meme #
# a ete introduite le 20030117142623. En particulier la regle '30' donne une structure #
# aleatoire, la regle '90' donne une structure fractale de type "Sierpinski", la regle #
# '250' donne une structure fixe... #
set VaLiDe=`echo $Regles | $GRE "^[$Alphabet_0_9]*"'$'`
if ("$VaLiDe" != "$K_VIDE") then
set Puissance=256
set LRegles=($K_VIDE)
set LRegles=($LRegles $PointNoir_$PointNoir_$PointNoir_$SeparateuR)
set LRegles=($LRegles $PointNoir_$PointNoir_$PointBlanc$SeparateuR)
set LRegles=($LRegles $PointNoir_$PointBlanc$PointNoir_$SeparateuR)
set LRegles=($LRegles $PointNoir_$PointBlanc$PointBlanc$SeparateuR)
set LRegles=($LRegles $PointBlanc$PointNoir_$PointNoir_$SeparateuR)
set LRegles=($LRegles $PointBlanc$PointNoir_$PointBlanc$SeparateuR)
set LRegles=($LRegles $PointBlanc$PointBlanc$PointNoir_$SeparateuR)
set LRegles=($LRegles $PointBlanc$PointBlanc$PointBlanc$SeparateuR)
set IRegles=1
# Liste des 8 regles a generer et index de parcours... #
if (($Regles < $Puissance) && ($Regles >= 0)) then
#20111214165404____: set Cumul="$K_VIDE" #
SET1 Cumul = "$K_VIDE"
set Nombre=$Regles
while ($Puissance > 1)
@ Puissance = $Puissance / 2
set Cumul="$Cumul"" $LRegles[$IRegles]"
if ($Nombre >= $Puissance) then
set Cumul="$Cumul""$PointNoir_"
# Cas d'un "1" binaire... #
@ Nombre = $Nombre - $Puissance
else
set Cumul="$Cumul""$PointBlanc"
# Cas d'un "0" binaire... #
endif
@ IRegles = $IRegles + 1
end
set Regles=`echo "$Cumul" | $SE -e "s/^ *//"`
else
EROR "Le numero du jeu de regles est incorrect (1)."
endif
else
EROR "Le numero du jeu de regles est incorrect (2)."
endif
else
endif
if ($#Regles > 8) then
EROR "Le nombre de regles maximal est 8 alors qu'il y en a $#Regles."
else
endif
if ($EditerRegles == $EXIST) then
echo "Regles utilisees : {$Regles}."
FileTmpB MiSe_A_JoUr_1 $sed
FileTmpB MiSe_A_JoUr_2 $sed
echo "$Regles" | \
$R "$K_BLANC" "$K_NL" | \
$GRE -v '^ *$' | \
$AW ' { print "s/" $1 "/" $1 "/" } ' | \
$SE -e "s/\(=\)./\1?/1" \
> $MiSe_A_JoUr_1
$CA $MiSe_A_JoUr_1 | \
$SE -e "s/=/:/g" \
-e 's+\(/\)[^/]*:\(./\)$+\1\2+' \
> $MiSe_A_JoUr_2
$CA $xci/AutoC_1DB.01$D/cubes.01$vv$T | \
$SE -f $MiSe_A_JoUr_1 \
-f $MiSe_A_JoUr_2
# Edition des regles sous forme de deux cubes (introduite le 20081204091948)... #
FileTmpE MiSe_A_JoUr_2
FileTmpE MiSe_A_JoUr_1
else
endif
foreach Regle ($Regles)
# Un bon exemple est la regle numero '110' en notation francaise : #
# #
# "NNN=B NNB=N NBN=N NBB=B BNN=N BNB=N BBN=N BBB=B" #
# #
# ou en notation anglaise : #
# #
# "BBB=W BBW=B BWB=B BWW=W WBB=B WBW=B WWB=B WWW=W" #
# #
# en prenant "bord=$BLANC" pour eviter les effets de bord... #
set Points=`echo "$Regle" | $SE -e "s/$SeparateuR//" -e "s/\(.\)/\1 /g" -e 's/ *$//'`
if ($#Points == 4) then
if ($Points[1] == $PointNoir_) then
set PointGauche=$NOIR
else
if ($Points[1] == $PointBlanc) then
set PointGauche=$BLANC
else
EROR "La regle '$Regle' est mal formee (1)."
set PointGauche=$NOIR
endif
endif
if ($Points[2] == $PointNoir_) then
set PointCourantAvant=$NOIR
else
if ($Points[2] == $PointBlanc) then
set PointCourantAvant=$BLANC
else
EROR "La regle '$Regle' est mal formee (2)."
set PointCourantAvant=$NOIR
endif
endif
if ($Points[3] == $PointNoir_) then
set PointDroite=$NOIR
else
if ($Points[3] == $PointBlanc) then
set PointDroite=$BLANC
else
EROR "La regle '$Regle' est mal formee (3)."
set PointDroite=$NOIR
endif
endif
if ($Points[4] == $PointNoir_) then
set PointCourantApres=$NOIR
else
if ($Points[4] == $PointBlanc) then
set PointCourantApres=$BLANC
else
EROR "La regle '$Regle' est mal formee (4)."
set PointCourantApres=$NOIR
endif
endif
set PointCourantAvant=`$xci/nombres$X A="$K_VIDE" premiere=$PointCourantAvant derniere=$PointCourantAvant`
$xci/S_point$X A=$TableMultiplication.$PointCourantAvant \
X=$PointDroite Y=$PointGauche \
niveau=$PointCourantApres \
R=$TableMultiplication.$PointCourantAvant \
$formatI
# On n'oubliera pas les correspondances suivantes : #
# #
# point_a_gauche --> Y #
# point__courant --> Z #
# point_a_droite --> X #
# #
# soit encore : #
# #
# X --> point_a_droite #
# Y --> point_a_gauche #
# Z --> point__courant #
# #
# ('v $xiii/Images$DEF AUTOMATE_CELLULAIRE.automate_cellulaire'). #
else
EROR "La regle '$Regle' est mal formee (5)."
endif
end
if ($RendreContinu == $EXIST) then
# Test introduit le 20081122174922... #
alias GetNiVo 'set CooX=\!:1 ; set CooY=\!:2 ; set CooZ=\!:3 ; \\
set NuMeRo=`$xci/nombres$X A="$K_VIDE" premiere=$CooZ derniere=$CooZ` ; \\
$xci/print$X A=$TableMultiplication.$NuMeRo X=$CooX Y=$CooY editerX=FAUX editerY=FAUX Prme=VRAI ; \\
unset CooX CooY CooZ NuMeRo'
# Recuperation de l'automate cellulaire binaire... #
set Niveau_X0_Y0_Z0=`GetNiVo $NOIR $NOIR $NOIR`
set Niveau_X0_Y0_Z1=`GetNiVo $NOIR $NOIR $BLANC`
set Niveau_X1_Y0_Z0=`GetNiVo $BLANC $NOIR $NOIR`
set Niveau_X1_Y0_Z1=`GetNiVo $BLANC $NOIR $BLANC`
set Niveau_X1_Y1_Z0=`GetNiVo $BLANC $BLANC $NOIR`
set Niveau_X1_Y1_Z1=`GetNiVo $BLANC $BLANC $BLANC`
set Niveau_X0_Y1_Z0=`GetNiVo $NOIR $BLANC $NOIR`
set Niveau_X0_Y1_Z1=`GetNiVo $NOIR $BLANC $BLANC`
unalias GetNiVo
FileTmpB File_Niv_X0_Y0
FileTmpB File_Niv_X1_Y0
FileTmpB File_Niv_X1_Y1
FileTmpB File_Niv_X0_Y1
FileTmpB File_Z
FileTmpB File_CoMmAnDeS
FileTmpB File_CoNtInU $Y
if ($Multiple == 1) then
set RendreMultiple="multiple=FAUX"
else
set RendreMultiple="multiple=VRAI unite=$Multiple"
# Possibilite introduite le 20081126144027 afin d'introduire des "discontinuites" dans #
# les interpolations qui suivent... #
endif
$xci/valeurs_inte$X premiere=$NOIR derniere=$BLANC \
lineaire=VRAI \
entiers=VRAI epsilon=0.000001 \
$RendreMultiple \
vD=$Niveau_X0_Y0_Z0 vA=$Niveau_X0_Y0_Z1 \
> $File_Niv_X0_Y0
# Interpolation du niveau suivant la coordonnee 'Z' pour X=0 et Y=0. #
$xci/valeurs_inte$X premiere=$NOIR derniere=$BLANC \
lineaire=VRAI \
entiers=VRAI epsilon=0.000001 \
$RendreMultiple \
vD=$Niveau_X1_Y0_Z0 vA=$Niveau_X1_Y0_Z1 \
> $File_Niv_X1_Y0
# Interpolation du niveau suivant la coordonnee 'Z' pour X=1 et Y=0. #
$xci/valeurs_inte$X premiere=$NOIR derniere=$BLANC \
lineaire=VRAI \
entiers=VRAI epsilon=0.000001 \
$RendreMultiple \
vD=$Niveau_X1_Y1_Z0 vA=$Niveau_X1_Y1_Z1 \
> $File_Niv_X1_Y1
# Interpolation du niveau suivant la coordonnee 'Z' pour X=1 et Y=1. #
$xci/valeurs_inte$X premiere=$NOIR derniere=$BLANC \
lineaire=VRAI \
entiers=VRAI epsilon=0.000001 \
$RendreMultiple \
vD=$Niveau_X0_Y1_Z0 vA=$Niveau_X0_Y1_Z1 \
> $File_Niv_X0_Y1
# Interpolation du niveau suivant la coordonnee 'Z' pour X=0 et Y=1. #
$xci/nombres$X A="$K_VIDE" \
premiere=$NOIR derniere=$BLANC | \
$R "$K_BLANC" "$K_NL" | \
$GRE -v '^ *$' \
> $File_Z
# Interpolation de la coordonnee 'Z'... #
# #
# On notera le "epsilon=0.000001" destine en particulier a faire que si 'vD=vA' (par exemple #
# egal a '$BLANC'...), alors toutes les valeurs entieres editees sont egales entre-elles et #
# aux bornes 'vD' et 'vA"... #
set FoRmAtR=`echo $formatI | $SE -e "s/\(=\)/R\1/g"`
set VaLiDeA="ValiderAxes=FAUX"
set ChAiNe0='$xci/init$X niveau=$NOIR'
set ChAiNe1=' $VaLiDeA $formatI | $xci/S_point$X x=$Xmin y=$Ymin niveau='
set ChAiNe2=' $VaLiDeA $formatI | $xci/S_point$X x=$Xmax y=$Ymin niveau='
set ChAiNe3=' $VaLiDeA $formatI | $xci/S_point$X x=$Xmax y=$Ymax niveau='
set ChAiNe4=' $VaLiDeA $formatI | $xci/S_point$X x=$Xmin y=$Ymax niveau='
set ChAiNe5=' $VaLiDeA $formatI | $xci/format.01$X mode=1 R=$TableMultiplication.'
set ChAiNe6=' $VaLiDeA $FoRmAtR'
# Definition des commandes destinees a rendre "pseudo-continu" l'automate cellulaire par #
# interpolation via '$xci/format.01$X mode=1'. On notera qu'il serait aussi possible #
# d'utiliser '$xci/fract_2D.01$X source=VRAI', mais le passage par des coordonnees {X,Y} #
# normalisees (et donc des conversions entiers <--> flottants) risque de conduire, de temps #
# en temps, a des anomalies... #
$PAST $File_Niv_X0_Y0 $File_Niv_X1_Y0 $File_Niv_X1_Y1 $File_Niv_X0_Y1 $File_Z | \
$AW ' { print "=0==1=" $1 "=2=" $2 "=3=" $3 "=4=" $4 "=5=" $5 "=6=" } ' | \
$SE -e "s+=0=+$ChAiNe0+" \
-e "s+=1=+$ChAiNe1+" \
-e "s+=2=+$ChAiNe2+" \
-e "s+=3=+$ChAiNe3+" \
-e "s+=4=+$ChAiNe4+" \
-e "s+=5=+$ChAiNe5+" \
-e "s+=6=+$ChAiNe6+" \
> $File_CoMmAnDeS
$CA $xcs/csh$Y \
> $File_CoNtInU
$CA $File_CoMmAnDeS \
>>! $File_CoNtInU
SformatI
XYmaxNe 0 1 0 1
source $File_CoNtInU
RformatI
# Et ainsi, on rend "pseudo-continu" l'automate cellulaire binaire... #
FileTmpE File_CoNtInU
FileTmpE File_CoMmAnDeS
FileTmpE File_Z
FileTmpE File_Niv_X0_Y1
FileTmpE File_Niv_X1_Y1
FileTmpE File_Niv_X1_Y0
FileTmpE File_Niv_X0_Y0
else
endif