Initialisation du projet pst-solides3d.git (SVN revision 142)

[pst-solides3d.git] / tests / .svn / text-base / test_04.ps.svn-base

%!PS-Adobe-2.0
%%Creator: dvips(k) 5.96dev Copyright 2007 Radical Eye Software
%%Title: test_04.dvi
%%CreationDate: Sun Jul 13 14:11:44 2008
%%Pages: 2
%%PageOrder: Ascend
%%BoundingBox: 0 0 596 842
%%DocumentFonts: SFTT1728 SFRM1728 SFRM1200 SFBX1440 SFRM1000
%%DocumentPaperSizes: a4
%%EndComments
%DVIPSWebPage: (www.radicaleye.com)
%DVIPSCommandLine: dvips test_04.dvi
%DVIPSParameters: dpi=600
%DVIPSSource:  TeX output 2008.07.13:1411
%%BeginProcSet: tex.pro 0 0
%!
/TeXDict 300 dict def TeXDict begin/N{def}def/B{bind def}N/S{exch}N/X{S
N}B/A{dup}B/TR{translate}N/isls false N/vsize 11 72 mul N/hsize 8.5 72
mul N/landplus90{false}def/@rigin{isls{[0 landplus90{1 -1}{-1 1}ifelse 0
0 0]concat}if 72 Resolution div 72 VResolution div neg scale isls{
landplus90{VResolution 72 div vsize mul 0 exch}{Resolution -72 div hsize
mul 0}ifelse TR}if Resolution VResolution vsize -72 div 1 add mul TR[
matrix currentmatrix{A A round sub abs 0.00001 lt{round}if}forall round
exch round exch]setmatrix}N/@landscape{/isls true N}B/@manualfeed{
statusdict/manualfeed true put}B/@copies{/#copies X}B/FMat[1 0 0 -1 0 0]
N/FBB[0 0 0 0]N/nn 0 N/IEn 0 N/ctr 0 N/df-tail{/nn 8 dict N nn begin
/FontType 3 N/FontMatrix fntrx N/FontBBox FBB N string/base X array
/BitMaps X/BuildChar{CharBuilder}N/Encoding IEn N end A{/foo setfont}2
array copy cvx N load 0 nn put/ctr 0 N[}B/sf 0 N/df{/sf 1 N/fntrx FMat N
df-tail}B/dfs{div/sf X/fntrx[sf 0 0 sf neg 0 0]N df-tail}B/E{pop nn A
definefont setfont}B/Cw{Cd A length 5 sub get}B/Ch{Cd A length 4 sub get
}B/Cx{128 Cd A length 3 sub get sub}B/Cy{Cd A length 2 sub get 127 sub}
B/Cdx{Cd A length 1 sub get}B/Ci{Cd A type/stringtype ne{ctr get/ctr ctr
1 add N}if}B/CharBuilder{save 3 1 roll S A/base get 2 index get S
/BitMaps get S get/Cd X pop/ctr 0 N Cdx 0 Cx Cy Ch sub Cx Cw add Cy
setcachedevice Cw Ch true[1 0 0 -1 -.1 Cx sub Cy .1 sub]{Ci}imagemask
restore}B/D{/cc X A type/stringtype ne{]}if nn/base get cc ctr put nn
/BitMaps get S ctr S sf 1 ne{A A length 1 sub A 2 index S get sf div put
}if put/ctr ctr 1 add N}B/I{cc 1 add D}B/bop{userdict/bop-hook known{
bop-hook}if/SI save N @rigin 0 0 moveto/V matrix currentmatrix A 1 get A
mul exch 0 get A mul add .99 lt{/QV}{/RV}ifelse load def pop pop}N/eop{
SI restore userdict/eop-hook known{eop-hook}if showpage}N/@start{
userdict/start-hook known{start-hook}if pop/VResolution X/Resolution X
1000 div/DVImag X/IEn 256 array N 2 string 0 1 255{IEn S A 360 add 36 4
index cvrs cvn put}for pop 65781.76 div/vsize X 65781.76 div/hsize X}N
/p{show}N/RMat[1 0 0 -1 0 0]N/BDot 260 string N/Rx 0 N/Ry 0 N/V{}B/RV/v{
/Ry X/Rx X V}B statusdict begin/product where{pop false[(Display)(NeXT)
(LaserWriter 16/600)]{A length product length le{A length product exch 0
exch getinterval eq{pop true exit}if}{pop}ifelse}forall}{false}ifelse
end{{gsave TR -.1 .1 TR 1 1 scale Rx Ry false RMat{BDot}imagemask
grestore}}{{gsave TR -.1 .1 TR Rx Ry scale 1 1 false RMat{BDot}
imagemask grestore}}ifelse B/QV{gsave newpath transform round exch round
exch itransform moveto Rx 0 rlineto 0 Ry neg rlineto Rx neg 0 rlineto
fill grestore}B/a{moveto}B/delta 0 N/tail{A/delta X 0 rmoveto}B/M{S p
delta add tail}B/b{S p tail}B/c{-4 M}B/d{-3 M}B/e{-2 M}B/f{-1 M}B/g{0 M}
B/h{1 M}B/i{2 M}B/j{3 M}B/k{4 M}B/w{0 rmoveto}B/l{p -4 w}B/m{p -3 w}B/n{
p -2 w}B/o{p -1 w}B/q{p 1 w}B/r{p 2 w}B/s{p 3 w}B/t{p 4 w}B/x{0 S
rmoveto}B/y{3 2 roll p a}B/bos{/SS save N}B/eos{SS restore}B end

%%EndProcSet
%%BeginProcSet: pstricks.pro 0 0
% $Id: pstricks.pro 34 2008-06-25 17:20:01Z herbert $
%
%% PostScript prologue for pstricks.tex.
%% Version 1.05, 2008/06/25
%%
%% This program can be redistributed and/or modified under the terms
%% of the LaTeX Project Public License Distributed from CTAN archives
%% in directory macros/latex/base/lppl.txt.
%
%
% Define the follwing gs-functions if not known, eg when using distiller
%
systemdict /.setopacityalpha known not {/.setopacityalpha { pop } def } if
systemdict /.setblendmode known not {/.setblendmode { pop } def } if
systemdict /.setshapealpha known not {/.setshapealpha { pop } def } if
%
/tx@Dict 200 dict def                           % the main PSTricks dictionary
tx@Dict begin
/ADict 25 dict def                              % The arrow dictionaray
/CM { matrix currentmatrix } bind def
/SLW /setlinewidth load def
/CLW /currentlinewidth load def
/CP /currentpoint load def
/ED { exch def } bind def
/L /lineto load def
/T /translate load def
/TMatrix { } def
/RAngle { 0 } def
/Sqrt { dup 0 lt { pop 0 } { sqrt } ifelse } def  % return 0 for negative arguments 
/Atan { /atan load stopped { pop pop 0 } if } def % return 0 if atan not known
/ATAN1 {neg -1 atan 180 sub } def               % atan(x) (only one parameter)
/Div { dup 0 eq { pop } { div } ifelse } def    % control the division
/tan { dup cos abs 1.e-10 lt 
  { pop 1.e10 }                                 % return 1.e10 as infinit
  { dup sin exch cos div } ifelse               % default sin/cos
} def
/Tan { dup sin exch cos Div } def               % sin(x)/cos(x) x in degrees
/Acos {dup dup mul neg 1 add dup 0 lt {         % arc cos, returns 0 when negative root
  pop pop 0 }{ sqrt exch atan} ifelse } def
/NET { neg exch neg exch T } def                % change coordinate system to the negative one          
/Pyth { dup mul exch dup mul add sqrt } def     % Pythagoras, expects 2 parameter
/Pyth2 {                                        % Pythagoras, xA yA xB yB
  3 -1 roll             % xA xB yB yA
  sub                   % xA xB yB-yA
  3 1 roll              % yB-yA xA xB
  sub                   % yB-yA xA-xB
  Pyth } def
/PtoC { 2 copy cos mul 3 1 roll sin mul } def   % Polar to Cartesian
/Rand { rand 4294967295 div } def               % a real random number
%----------------- hv added 20050516 ---------------
/PiDiv2 1.57079632680 def
/Pi 3.14159265359 def 
/TwoPi 6.28318530718 def
/Euler 2.71828182846 def 
%/e Euler bind def
/RadtoDeg { 180 mul Pi div } bind def           % convert from radian to degrees
/DegtoRad { Pi mul 180 div } bind def           % viceversa
%----------------- hv end---------------------------
/PathLength@ { /z z y y1 sub x x1 sub Pyth add def /y1 y def /x1 x def } def
/PathLength { 
  flattenpath /z 0 def 
  { /y1 ED /x1 ED /y2 y1 def /x2 x1 def }
  { /y ED /x ED PathLength@ } 
  {} 
  { /y y2 def /x x2 def PathLength@ }
  /pathforall load stopped { pop pop pop pop } if 
  z 
} def
%
/STP { .996264 dup scale } def                  % BP/PT scaling
/STV { SDict begin normalscale end STP  } def   % 
%
%%-------------- DG begin patch 15 ---------------%%
%/DashLine { dup 0 gt { /a .5 def PathLength exch div } { pop /a 1 def
%PathLength } ifelse /b ED /x ED /y ED /z y x add def b a .5 sub 2 mul y
%mul sub z Div round z mul a .5 sub 2 mul y mul add b exch Div dup y mul
%/y ED x mul /x ED x 0 gt y 0 gt and { [ y x ] 1 a sub y mul } { [ 1 0 ]
%0 } ifelse setdash stroke } def
/DashLine {
  dup 0 gt { /a .5 def PathLength exch div } { pop /a 1 def PathLength } ifelse
  /b ED /x1 ED /y1 ED /x ED /y ED 
  /z y x add y1 add x1 add def
  /Coef b a .5 sub 2 mul y mul sub z Div round 
    z mul a .5 sub 2 mul y mul add b exch Div def 
  /y y Coef mul def 
  /x x Coef mul def 
  /y1 y1 Coef mul def 
  /x1 x1 Coef mul def
  x1 0 gt y1 0 gt or x 0 gt or y 0 gt and 
    { [ y x y1 x1 ] 1 a sub y mul }
    { [ 1 0 ] 0 } ifelse 
  setdash stroke
} def
%%-------------- DG end patch 15 ---------------%%
/DotLine { 
  /b PathLength def 
  /a ED /z ED /y CLW def 
  /z y z add def 
  a 0 gt { 
    /b b a div def 
  }{ 
    a 0 eq { 
      /b b y sub def 
    }{ a -3 eq { 
      /b b y add def } if 
    } ifelse 
  } ifelse 
  [ 0 b b z Div round Div dup 0 le { pop 1 } if ] 
  a 0 gt { 0 }{ y 2 div a -2 gt { neg }if } ifelse 
  setdash 1 setlinecap stroke 
} def
%
/LineFill { % hv ------------ patch 7 -------------
  gsave 
  abs /hatchWidthInc ED
  abs /hatchSepInc ED
  abs CLW add /a ED 
  a 0 dtransform round exch round exch
  2 copy idtransform 
  exch Atan rotate 
  idtransform pop /a ED 
  .25 .25 itransform pathbbox 
  /y2 ED 
  a Div ceiling cvi /x2 ED /y1 ED 
  a Div cvi /x1 ED /y2 y2 y1 sub def 
  clip 
  newpath 
  2 setlinecap 
  systemdict
  /setstrokeadjust known { true setstrokeadjust } if 
  x2 x1 sub 1 add { 
    x1 a mul y1 moveto 0 y2 rlineto stroke 
    /x1 x1 1 add 
      hatchWidthInc 0 gt { CLW add } if 
    def 
    hatchSepInc 0 gt hatchWidthInc 0 gt or { 
      /a a hatchSepInc add def
      CLW hatchWidthInc add SLW 
    } if
  } repeat 
  grestore 
  pop pop } def
%
/PenroseFill {%  on stack: scaling factor
  dup dup scale
  1 exch div round /penroseFactor ED 
  a 0 dtransform round exch round exch
  2 copy idtransform 
  exch Atan rotate 
  idtransform pop /a ED 
  .25 .25 itransform pathbbox 
  /y2 ED 
  a Div ceiling cvi /x2 ED /y1 ED 
  a Div cvi /x1 ED /y2 y2 y1 sub def 
  clip 
  newpath 
  systemdict
  /setstrokeadjust known { true setstrokeadjust } if 
  /I/S/L/W/G/+/Z/F/E/D[/def/exch/for{E D}/add{s E get mul}
 { Z -36.2001 1 33 }{25 E S rlineto}{/q Z dup q G E q 1 + G}{Z 2 2}]{cvx def}forall
  [0 72 1008 {dup sin E cos }F ]1 setlinejoin/s W{/a W{/b I 10{/i I 4{/m I moveto
  i m +/j I 10{/l Z b m l + G a l G sub s m get div .2 + floor .3 + 25
  mul j l + S rmoveto}F i L j L stroke }F}F}F}F 
  grestore 
  pop pop 
} def
%
%gsave abs CLW add /a ED a 0 dtransform round exch round exch
%2 copy idtransform exch Atan rotate idtransform pop /a ED .25 .25
%% DG/SR modification begin - Dec. 12, 1997 - Patch 2
%%itransform translate pathbbox /y2 ED a Div ceiling cvi /x2 ED /y1 ED a
%itransform pathbbox /y2 ED a Div ceiling cvi /x2 ED /y1 ED a
%% DG/SR modification end
%Div cvi /x1 ED /y2 y2 y1 sub def clip newpath 2 setlinecap systemdict
%/setstrokeadjust known { true setstrokeadjust } if x2 x1 sub 1 add { x1
%% DG/SR modification begin - Jun.  1, 1998 - Patch 3 (from Michael Vulis)
%% a mul y1 moveto 0 y2 rlineto stroke /x1 x1 1 add def } repeat grestore }
%% def
%a mul y1 moveto 0 y2 rlineto stroke /x1 x1 1 add def } repeat grestore
%pop pop } def
%% DG/SR modification end
%
/BeginArrow { 
  ADict begin                   % hold it local, for end see EndArrow
  /@mtrx CM def 
  gsave 
  2 copy T 
  2 index sub neg exch 
  3 index sub exch Atan 
  rotate newpath 
} def
%
/EndArrow { @mtrx setmatrix CP grestore end } def % end the ADict
%
/Arrow { 
  CLW mul add dup 
  2 div /w ED 
  mul dup /h ED 
  mul /a ED 
  { 0 h T 1 -1 scale } if 
  w neg h moveto 
  0 0 L w h L w neg a neg rlineto 
  gsave fill grestore 
} def
%
/ArrowD { % the sides are drawn as curves (hv 20071211)
  CLW mul add dup 
  2 div /w ED 
  mul dup /h ED 
  mul /Inset ED 
  { 0 h T 1 -1 scale } if % changes the direction
% we use y=w/h^2 * x^2 as equation for the control points
% for the coordinates the arrow is seen from top to bottom
% the bottom (tip) is (0;0)
  w neg h moveto % lower left of >
  w 9 div 4 mul neg h 3 div 2 mul
  w 9 div neg       h 3 div  
  0 0 curveto    % tip of >
  w 9 div        h 3 div  
  w 9 div 4 mul  h 3 div 2 mul
  w h curveto % upper left of >
  w neg Inset neg rlineto % move to x=0 and inset
  gsave fill grestore 
} def 
%
/Tbar { 
  CLW mul add /z ED 
  z -2 div CLW 2 div moveto 
  z 0 rlineto stroke 
  0 CLW moveto 
} def
%
/Bracket { 
  CLW mul add dup CLW sub 2 div 
  /x ED mul CLW add /y ED /z CLW 2 div def 
  x neg y moveto 
  x neg CLW 2 div L x CLW 2 div L x y L stroke 
  0 CLW moveto 
} def
%
/RoundBracket { 
  CLW mul add dup 2 div 
  /x ED mul /y ED /mtrx CM def 
  0 CLW 2 div T x y mul 0 ne { x y scale } if 
  1 1 moveto 
  .85 .5 .35 0 0 0 curveto 
  -.35 0 -.85 .5 -1 1 curveto 
  mtrx setmatrix stroke 0 CLW moveto 
} def
%
/SD { 0 360 arc fill } def
%
/EndDot { % DS is the dot size 
  { /z DS def } { /z 0 def } ifelse 
  /b ED 0 z DS SD b { 0 z DS CLW sub SD } if 
  0 DS z add CLW 4 div sub moveto } def
%
/Shadow { [ { /moveto load } { /lineto load } { /curveto load } {
  /closepath load } /pathforall load stopped { pop pop pop pop CP /moveto
  load } if ] cvx newpath 3 1 roll T exec } def
%
%/NArray { 
%   aload length 2 div dup dup cvi eq not { exch pop } if /n exch
%   cvi def 
%} def
%
/NArray { % holds the coordinates and on top of stack the showpoints boolean
  /showpoints ED 
  counttomark 2 div dup cvi /n ED 
  n eq not { exch pop } if
  showpoints { ] aload /Points ED } { n 2 mul 1 add -1 roll pop } ifelse 
} def
%
/Line { 
  NArray n 0 eq not 
    { n 1 eq { 0 0 /n 2 def } if ArrowA /n n 2 sub def 
      n { Lineto } repeat 
      CP 4 2 roll ArrowB L pop pop 
    } if 
} def
%
/Arcto { 
  /a [ 6 -2 roll ] cvx def 
  a r 
  /arcto load stopped { 5 } { 4 } ifelse { pop } repeat 
  a 
} def
%
/CheckClosed { dup n 2 mul 1 sub index eq 2 index n 2 mul 1 add index eq
  and { pop pop /n n 1 sub def } if } def
/Polygon { NArray n 2 eq { 0 0 /n 3 def } if n 3 lt { n { pop pop }
  repeat } { n 3 gt { CheckClosed } if n 2 mul -2 roll /y0 ED /x0 ED /y1
  ED /x1 ED x1 y1 /x1 x0 x1 add 2 div def /y1 y0 y1 add 2 div def x1 y1
  moveto /n n 2 sub def n { Lineto } repeat x1 y1 x0 y0 6 4 roll Lineto
  Lineto pop pop closepath } ifelse } def
/Diamond { 
  /mtrx CM def 
  T rotate 
  /h ED 
  /w ED 
  dup 0 eq { pop } { CLW mul neg 
    /d ED 
    /a w h Atan def 
    /h d a sin Div h add def 
    /w d a cos Div w add def } ifelse 
  mark w 2 div h 2 div w 0 0 h neg w neg 0 0 h w 2 div h 2 div 
  /ArrowA { moveto } def 
  /ArrowB { } def 
  false Line 
  closepath mtrx setmatrix } def
% DG modification begin - Jan. 15, 1997
%/Triangle { /mtrx CM def translate rotate /h ED 2 div /w ED dup 0 eq {
%pop } { CLW mul /d ED /h h d w h Atan sin Div sub def /w w d h w Atan 2
%div dup cos exch sin Div mul sub def } ifelse mark 0 d w neg d 0 h w d 0
%d /ArrowA { moveto } def /ArrowB { } def false Line closepath mtrx
%setmatrix } def
/Triangle { /mtrx CM def translate rotate /h ED 2 div /w ED dup
CLW mul /d ED /h h d w h Atan sin Div sub def /w w d h w Atan 2
div dup cos exch sin Div mul sub def mark 0 d w neg d 0 h w d 0
d /ArrowA { moveto } def /ArrowB { } def false Line closepath mtrx
% DG/SR modification begin - Jun.  1, 1998 - Patch 3 (from Michael Vulis)
% setmatrix } def
setmatrix pop } def
% DG/SR modification end
%
/CCA { 
  /y ED /x ED 
  2 copy y sub /dy1 ED 
  x sub /dx1 ED 
  /l1 dx1 dy1 Pyth def 
} def
%
/CC { 
  /l0 l1 def 
  /x1 x dx sub def 
  /y1 y dy sub def 
  /dx0 dx1 def 
  /dy0 dy1 def 
  CCA 
  /dx dx0 l1 c exp mul dx1 l0 c exp mul add def 
  /dy dy0 l1 c exp mul dy1 l0 c exp mul add def 
  /m dx0 dy0 Atan dx1 dy1 Atan sub 2 div cos abs b exp a mul dx dy Pyth Div 2 div def 
  /x2 x l0 dx mul m mul sub def
  /y2 y l0 dy mul m mul sub def 
  /dx l1 dx mul m mul neg def 
  /dy l1 dy mul m mul neg def 
} def
%
/IC { 
  /c c 1 add def 
  c 0 lt { /c 0 def } { c 3 gt { /c 3 def } if } ifelse 
  /a a 2 mul 3 div 45 cos b exp div def 
  CCA 
  /dx 0 def 
  /dy 0 def 
} def
%
/BOC { IC CC x2 y2 x1 y1 ArrowA CP 4 2 roll x y curveto } def
/NC { CC x1 y1 x2 y2 x y curveto } def
/EOC { x dx sub y dy sub 4 2 roll ArrowB 2 copy curveto } def
/BAC { IC CC x y moveto CC x1 y1 CP ArrowA } def
/NAC { x2 y2 x y curveto CC x1 y1 } def
/EAC { x2 y2 x y ArrowB curveto pop pop } def
%
/OpenCurve { 
  NArray n 3 lt 
    { n { pop pop } repeat } 
    { BOC /n n 3 sub def n { NC } repeat EOC } ifelse 
} def
%
/AltCurve { 
  { false NArray n 2 mul 2 roll 
    [ n 2 mul 3 sub 1 roll ] aload
    /Points ED 
    n 2 mul -2 roll } 
  { false NArray } ifelse 
  n 4 lt { n { pop pop } repeat } { BAC /n n 4 sub def n { NAC } repeat EAC } ifelse 
} def
%
/ClosedCurve { 
  NArray n 3 lt 
    { n { pop pop } repeat } 
    { n 3 gt { CheckClosed } if 
      6 copy n 2 mul 6 add 6 roll 
      IC CC x y moveto n { NC } repeat 
      closepath pop pop 
    } ifelse 
} def
%
/SQ { /r ED r r moveto r r neg L r neg r neg L r neg r L fill } def
/ST { /y ED /x ED x y moveto x neg y L 0 x L fill } def
/SP { /r ED gsave 0 r moveto 4 { 72 rotate 0 r L } repeat fill grestore }
def
/FontDot { DS 2 mul dup matrix scale matrix concatmatrix exch matrix
rotate matrix concatmatrix exch findfont exch makefont setfont } def
/Rect { x1 y1 y2 add 2 div moveto x1 y2 lineto x2 y2 lineto x2 y1 lineto
x1 y1 lineto closepath } def
/OvalFrame { x1 x2 eq y1 y2 eq or { pop pop x1 y1 moveto x2 y2 L } { y1
y2 sub abs x1 x2 sub abs 2 copy gt { exch pop } { pop } ifelse 2 div
exch { dup 3 1 roll mul exch } if 2 copy lt { pop } { exch pop } ifelse
/b ED x1 y1 y2 add 2 div moveto x1 y2 x2 y2 b arcto x2 y2 x2 y1 b arcto
x2 y1 x1 y1 b arcto x1 y1 x1 y2 b arcto 16 { pop } repeat closepath }
ifelse } def
/Frame { CLW mul /a ED 3 -1 roll 2 copy gt { exch } if a sub /y2 ED a add
/y1 ED 2 copy gt { exch } if a sub /x2 ED a add /x1 ED 1 index 0 eq {
pop pop Rect } { OvalFrame } ifelse } def
%
/BezierNArray { 
  /f ED 
  counttomark 2 div dup cvi /n ED 
  n eq not { exch pop } if 
  n 1 sub neg 3 mod 3 add 3 mod { 0 0 /n n 1 add def } repeat 
  f { ] aload /Points ED } { n 2 mul 1 add -1 roll pop } ifelse 
} def
%
/OpenBezier { 
  BezierNArray 
  n 1 eq 
    { pop pop } 
    { ArrowA n 4 sub 3 idiv 
      { 6 2 roll 4 2 roll curveto } repeat 
      6 2 roll 4 2 roll ArrowB curveto } ifelse 
} def
%
/ClosedBezier { 
  BezierNArray 
  n 1 eq 
    { pop pop } 
    { moveto n 1 sub 3 idiv 
      { 6 2 roll 4 2 roll curveto } repeat 
      closepath } ifelse 
} def
%
/BezierShowPoints { 
  gsave 
  Points aload length 2 div cvi /n ED 
  moveto 
  n 1 sub { lineto } repeat 
  CLW 2 div SLW [ 4 4 ] 0 setdash stroke 
  grestore 
} def
%
/Parab { 
  /y0 ED /x0 ED /y1 ED /x1 ED 
  /dx x0 x1 sub 3 div def 
  /dy y0 y1 sub 3 div def 
  x0 dx sub y0 dy add x1 y1 ArrowA
  x0 dx add y0 dy add x0 2 mul x1 sub y1 ArrowB 
  curveto 
  /Points [ x1 y1 x0 y0 x0 2 mul x1 sub y1 ] def 
} def
%
/Grid { 
  newpath 
  /a 4 string def 
  /b ED /c ED /n ED 
  cvi dup 1 lt { pop 1 } if 
  /s ED 
  s div dup 0 eq { pop 1 } if 
  /dy ED s div dup 0 eq { pop 1 } if
  /dx ED dy div round dy mul 
  /y0 ED dx div round dx mul 
  /x0 ED dy div round cvi 
  /y2 ED dx div round cvi 
  /x2 ED dy div round cvi 
  /y1 ED dx div round cvi 
  /x1 ED 
  /h y2 y1 sub 0 gt { 1 } { -1 } ifelse def 
  /w x2 x1 sub 0 gt { 1 } { -1 } ifelse def 
  b 0 gt { 
    /z1 b 4 div CLW 2 div add def
%    /Helvetica findfont b scalefont setfont 
    /b b .95 mul CLW 2 div add def } if 
  systemdict /setstrokeadjust known 
    { true setstrokeadjust /t { } def }
    { /t { transform 0.25 sub round 0.25 add exch 0.25 sub round 0.25 add
       exch itransform } bind def } ifelse 
  gsave n 0 gt { 1 setlinecap [ 0 dy n div ] dy n div 2 div setdash } { 2 setlinecap } ifelse 
  /i x1 def 
  /f y1 dy mul n 0 gt { dy n div 2 div h mul sub } if def 
  /g y2 dy mul n 0 gt { dy n div 2 div h mul add } if def 
  x2 x1 sub w mul 1 add dup 1000 gt { pop 1000 } if 
  { i dx mul dup y0 moveto 
    b 0 gt 
      { gsave c i a cvs dup stringwidth pop 
        /z2 ED w 0 gt {z1} {z1 z2 add neg} ifelse 
        h 0 gt {b neg}{z1} ifelse 
        rmoveto show grestore } if 
    dup t f moveto 
    g t L stroke 
    /i i w add def 
  } repeat 
  grestore 
  gsave 
  n 0 gt
  % DG/SR modification begin - Nov. 7, 1997 - Patch 1
  %{ 1 setlinecap [ 0 dx n div ] dy n div 2 div setdash }
    { 1 setlinecap [ 0 dx n div ] dx n div 2 div setdash }
  % DG/SR modification end
    { 2 setlinecap } ifelse 
  /i y1 def 
  /f x1 dx mul n 0 gt { dx n div 2 div w mul sub } if def 
  /g x2 dx mul n 0 gt { dx n div 2 div w mul add } if def 
  y2 y1 sub h mul 1 add dup 1000 gt { pop 1000 } if 
  { newpath i dy mul dup x0 exch moveto 
    b 0 gt { gsave c i a cvs dup stringwidth pop 
      /z2 ED 
      w 0 gt {z1 z2 add neg} {z1} ifelse 
      h 0 gt {z1} {b neg} ifelse 
      rmoveto show grestore } if 
    dup f exch t moveto 
    g exch t L stroke 
    /i i h add def 
  } repeat 
  grestore 
} def
%
/ArcArrow { 
  /d ED /b ED /a ED 
  gsave 
  newpath 0 -1000 moveto clip 
  newpath 
  0 1 0 0 b 
  grestore 
  c mul 
  /e ED 
  pop pop pop r a e d PtoC y add exch x add
  exch r a PtoC y add exch x add exch b pop pop pop pop a e d CLW 8 div c
  mul neg d 
} def
%
/Ellipse { /mtrx CM def T scale 0 0 1 5 3 roll arc mtrx setmatrix } def
%
/ArcAdjust { %%%% Vincent Guirardel
% given a target length (targetLength) and an initial angle (angle0) [in the stack],
% let  M(angle0)=(rx*cos(angle0),ry*sin(angle0))=(x0,y0).
% This computes an angle t such that (x0,y0) is at distance 
% targetLength from the point M(t)=(rx*cos(t),ry*sin(t)).
% NOTE: this an absolute angle, it does not have to be added or substracted to angle0
% contrary to TvZ's code.
% To achieve, this, one iterates the following process: start with some angle t,
% compute the point M' at distance targetLength of (x0,y0) on the semi-line [(x0,y0) M(t)].
% Now take t' (= new angle) so that (0,0) M(t') and M' are aligned.
%
% Another difference with TvZ's code is that we need d (=add/sub) to be defined.
% the value of d = add/sub is used to know on which side we have to move.
% It is only used in the initialisation of the angle before the iteration.
%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Input stack:  1: target length 2: initial angle
% variables used : rx, ry, d (=add/sub)
%
  /targetLength ED /angle0 ED
  /x0 rx angle0 cos mul def
  /y0 ry angle0 sin mul def
% we are looking for an angle t such that (x0,y0) is at distance targetLength 
% from the point M(t)=(rx*cos(t),ry*sin(t)))
%initialisation of angle (using 1st order approx = TvZ's code)
  targetLength 57.2958 mul
  angle0 sin rx mul dup mul
  angle0 cos ry mul dup mul
  add sqrt div 
% if initialisation angle is two large (more than 90 degrees) set it to 90 degrees
% (if the ellipse is very curved at the point where we draw the arrow, %
% the value can be much more than 360 degrees !)
% this should avoid going on the wrong side (more than 180 degrees) or go near
% a bad attractive point (at 180 degrees)
  dup 90 ge { pop 90 } if 
  angle0 exch d % add or sub
% maximum number of times to iterate the iterative procedure:
% iterative procedure: takes an angle t on top of stack, computes a 
% better angle (and put it on top of stack)
  30 { dup
% compute distance D between (x0,y0) and M(t)
    dup cos rx mul x0 sub dup mul exch sin ry mul y0 sub dup mul add sqrt
% if D almost equals targetLength, we stop
    dup targetLength sub abs 1e-5 le { pop exit } if
% stack now contains D t
% compute the point M(t') at distance targetLength of (x0,y0) on the semi-line [(x0,y0) M(t)]:
% M(t')= ( (x(t)-x0)*targetLength/d+x0 , (y(t)-y0)*targetLength/d+y0 )
    exch dup cos rx mul x0 sub  exch sin ry mul y0 sub
% stack contains:  y(t)-y0, x(t)-x0, d
    2 index Div targetLength mul y0 add ry Div exch
    2 index Div targetLength mul x0 add rx Div
% stack contains x(t')/rx , y(t')/ry , d
% now compute t', and remove D from stack
    atan exch pop
  } repeat
% we don't look at what happened... in particular, if targetLength is greater 
% than the diameter of the ellipse...
% the final angle will be around /angle0 + 180. maybe we should treat this pathological case...
% after iteration, stack contains an angle t such that M(t) is the tail of the arrow
% to give back the result as a an angle relative to angle0 we could add the following line:
% angle0 sub 0 exch d
%
% begin bug fix 2006-01-11
% we want to adjust the new angle t' by a multiple of 360 so that  | t'-angle0 | <= 180
%(we don't want to make the ellipse turn more or less than it should)...
dup angle0 sub dup abs 180 gt { 180 add 360 div floor 360 mul sub } { pop } ifelse
% end bug fix
} def
%
/EllipticArcArrow {
  /d ED      % is add or sub
  /b ED      % arrow procedure
  /a1 ED     % angle
  gsave
  newpath
  0 -1000 moveto
  clip                  % Set clippath far from arrow.
  newpath
  0 1 0 0 b             % Draw arrow to determine length.
  grestore
% Length of arrow is on top of stack. Next 3 numbers are junk.
%
  a1 exch ArcAdjust   % Angular position of base of arrow.
  /a2 ED
  pop pop pop
  a2 cos rx mul xOrig add % hv 2007-08-29   x->xOrig
  a2 sin ry mul yOrig add % hv 2007-08-29   y->yOrig
  a1 cos rx mul xOrig add % 
  a1 sin ry mul yOrig add % 
% Now arrow tip coor and base coor are on stack.
  b pop pop pop pop       % Draw arrow, and discard coordinates.
  a2 CLW 8 div
% change value of d (test it by looking if  `` 1 1 d '' gives 2 or not )
  1 1 d 2 eq { /d { sub } def } { /d { add } def } ifelse
  ArcAdjust
% resets original value of d
  1 1 d 2 eq { /d { sub } def } { /d { add } def } ifelse  % Adjust angle to give overlap.
} def
%%------------------ tvz/DG/hv (2004-05-10) end -------------------%%
%
/Rot { CP CP translate 3 -1 roll neg rotate NET  } def
%
/RotBegin { 
  tx@Dict /TMatrix known not { /TMatrix { } def /RAngle { 0 } def } if 
  /TMatrix [ TMatrix CM ] cvx def 
  /a ED 
  a Rot /RAngle [ RAngle dup a add ] cvx def 
} def
%
/RotEnd { /TMatrix [ TMatrix setmatrix ] cvx def /RAngle [ RAngle pop ] cvx def } def
%
/PutCoor { gsave CP T CM STV exch exec moveto setmatrix CP grestore } def
/PutBegin { /TMatrix [ TMatrix CM ] cvx def CP 4 2 roll T moveto } def
/PutEnd { CP /TMatrix [ TMatrix setmatrix ] cvx def moveto } def
/Uput { /a ED add 2 div /h ED 2 div /w ED /s a sin def /c a cos def /b s
abs c abs 2 copy gt dup /q ED { pop } { exch pop } ifelse def /w1 c b
div w mul def /h1 s b div h mul def q { w1 abs w sub dup c mul abs } {
h1 abs h sub dup s mul abs } ifelse } def
/UUput { /z ED abs /y ED /x ED q { x s div c mul abs y gt } { x c div s
mul abs y gt } ifelse { x x mul y y mul sub z z mul add sqrt z add } { q
{ x s div } { x c div } ifelse abs } ifelse a PtoC h1 add exch w1 add
exch } def
/BeginOL { dup (all) eq exch TheOL eq or { IfVisible not { Visible
/IfVisible true def } if } { IfVisible { Invisible /IfVisible false def
} if } ifelse } def
/InitOL { /OLUnit [ 3000 3000 matrix defaultmatrix dtransform ] cvx def
/Visible { CP OLUnit idtransform T moveto } def /Invisible { CP OLUnit
neg exch neg exch idtransform T moveto } def /BOL { BeginOL } def
/IfVisible true def } def
end
%-----------------------------------------------------------------------------%

% END pstricks.pro

%%EndProcSet
%%BeginProcSet: pst-algparser.pro 0 0
%!
% PostScript prologue for PSTricks algorithm parser
% Version 0.01, 2008/01/01
% For distribution and copyright, see pstricks.tex.   hv@pstricks.de
%
%-----------------------------------------------------------------------------%
/AlgParser { tx@AlgToPs begin AlgToPs end } def  % Dominique Rodriguez
%
/tx@CoreAnalyzerDict 100 dict def tx@CoreAnalyzerDict begin
%
% PS ANALYZER FOR ALGEBRAIC EXPRESSION V1.12
% E->T|E+T
% T->FS|T*FS
% FS -> F | +FS | -FS
% F->P|F^SF
% P->(E)|literal
% literal->number|var|var[E]|func(params)
% params->E|E,param
% number->TOBEFINISHED
%
%% E expression, T term, SF signed factor, F factor, P power
%
%% parser
%
%% str
%
%% C->E<condition_operators>E
%% STR index -> STR index+lenExpr
/AnalyzeCond { AnalyzeExpr ReadCondOp AnalyzeExpr EvalCondOp  } def
%
%% analyze Expression List (separator , or | )
%% STR index -> STR index+lenExpr
%% /AnalyzeListOfE {
%%   { NextNonBlankChar pop AnalyzeExpr%%dup Strlen eq { exit } if NextNonBlankChar
%%     NextNonBlankChar dup 0 eq { pop exit } if
%%     dup 44 ne 1 index 124 ne and { dup 41 ne { PROBLEMCONTACTBILLOU } { pop exit } ifelse } if
%%     pop NextNonBlankChar dup 0 eq { exit } if 124 ne { PROBLEMCONTACTBILLOU } if 1 add NextNonBlankChar 0 eq {toto} if } loop
%%   AnalyzeListOfEPostHook
%% } def
/AnalyzeListOfE {
  /NotFirst false def
  { NextNonBlankChar pop AnalyzeExpr
    NotFirst { EvalListOfExpr } { /NotFirst true def } ifelse
    dup Strlen eq { exit } if NextNonBlankChar
    dup 44 ne 1 index 124 ne and
    { dup 41 ne { PROBLEMCONTACTBILLOU } { pop exit } ifelse }
    if  pop 1 add } loop
  AnalyzeListOfEPostHook
} def
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% E->T|E+T
%% STR index -> STR index+lenExpr
/AnalyzeExpr {
  AnalyzePreHook AnalyzeTerm IsEndingExpr
  { dup 0 ne { 32 eq { NextNonBlankChar } if } { pop } ifelse }
  { { RollOp 1 add NextNonBlankChar pop AnalyzeTerm PreEvalHook EvalAddSub IsEndingExpr { pop exit } if } loop }
  ifelse
  AnalyzePostHook
} def
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% T->FS|T*FS
%% STR index
/AnalyzeTerm {
  AnalyzePreHook AnalyzeSignedFactor IsEndingTerm
  { dup 0 ne { 32 eq { NextNonBlankChar } if } { pop } ifelse }
  { { RollOp 1 add NextNonBlankChar pop AnalyzeSignedFactor PreEvalHook EvalMulDiv IsEndingTerm { pop exit } if} loop }
  ifelse
  AnalyzePostHook
} def
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% FS -> F | +FS | -FS
%% STR index
/AnalyzeSignedFactor {
  AnalyzePreHook 2 copy get dup IsUnaryOp
  { RollOp 1 add NextNonBlankChar pop AnalyzeSignedFactor EvalUnaryOp }
  { pop AnalyzeFactor }
  ifelse AnalyzePostHook
} def
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% F->P|F^P
%% STR index
/AnalyzeFactor {
  AnalyzePreHook AnalyzePower IsEndingFactor
  { dup 0 ne { 32 eq { NextNonBlankChar } if } { pop } ifelse }
  { { RollOp 1 add NextNonBlankChar pop AnalyzePower PreEvalHook EvalPower IsEndingFactor { pop exit } if} loop }
  ifelse  AnalyzePostHook
} def
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% P->(E)|literal
%% STR index
/AnalyzePower {
  %% depending of first char either a number, or a literal
  2 copy get dup 40 eq%%an open par
  { pop 1 add NextNonBlankChar pop AnalyzeExpr 1 add NextNonBlankChar pop }
  { AnalyzeLiteral }
  ifelse
} def
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% STR index STR[index] -> STR index
%/AnalyzeLiteral { IsNumber { EvalNumber } { EvalLiteral } ifelse } def
/AnalyzeLiteral { dup IsUnaryOp exch IsNumber or { EvalNumber } { EvalLiteral } ifelse } def%%dr 09102006
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% recognize + or -
%% chr -> T/F
/IsUnaryOp { dup 43 eq exch 45 eq or } bind def
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% a number can contain only : 0123456789.
%% chr -> T/F
/IsNumber { dup 48 ge exch dup 57 le 3 -1 roll and exch 46 eq or } bind def
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% STR index -> STR index number
%% a number can be of the form [0-9]*.[0-9]*\([eE][+-]?[0-9]+\)?
%% STR index -> STR index' number
/ReadNumber {
  exch dup 3 -1 roll dup 3 1 roll
  %%read mantissa
  { 1 add  2 copy dup Strlen eq { pop pop 0 exit } if get dup IsNumber not { exit } if pop } loop
  dup 101 eq exch 69 eq or
  %%% there is a "e" or "E" -> read exponant
  { 1 add 2 copy get dup IsUnaryOp
    { pop 1 add 2 copy get } if
    { IsNumber not { exit } if 1 add 2 copy get } loop }
  if
  dup 4 1 roll
  3 -1 roll exch 1 index sub getinterval
} def
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% a number can contain only : 0123456789.
%% chr -> T/F
/IsCondOp { dup 30 eq exch dup 60 ge exch 62 le and or } bind def
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% STR index -> STR index number
%% a number can be of the form [0-9]*.[0-9]*\([eE][+-]?[0-9]+\)?
%% STR index -> STR index' number
/ReadCondOp {
  NextNonBlankChar 1 index 4 1 roll
  { IsCondOp not { exit } if 1 add  2 copy get } loop
  2 copy 5 -1 roll
  exch 1 index sub getinterval 3 1 roll
} def
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% a literal can contain only : 0123456789.
%% chr -> T/F
/IsLiteral {%
  dup 48 ge exch dup  57 le 3 -1 roll and exch
  dup 65 ge exch dup  90 le 3 -1 roll and 3 -1 roll or exch
  dup 97 ge exch     122 le and or } bind def
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% a literal can be of the form [a-zA-Z][a-zA-Z0-9]*\(\((Expression)\)|\(\[Expression\]\)\)?
%% STR index -> literal STR index' nextchr
/ReadLiteral {
  exch dup 3 -1 roll dup 3 1 roll
  %%read literal core
  { 2 copy dup Strlen eq { pop pop 0 exit } if get dup IsLiteral not { exit } if pop 1 add } loop
  4 1 roll dup 5 1 roll 3 -1 roll exch 1 index sub getinterval 4 1 roll
} def
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% expr is ended by end of str or a clpar
%% STR index -> STR index STR[index] T/F
/IsEndingExpr {%
  2 copy dup Strlen eq
  %% if end of str is reached -> end !
  { pop pop 0 true }
  %% ending chr -> clpar, comma, |, <, >, =, !,
  {get dup  dup  41 eq
       exch dup 124 eq
       exch dup  93 eq
       exch dup  44 eq
       exch dup  30 eq
       exch dup  60 ge exch 62 le and or or or or or}
  ifelse } def
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% expr is ended by end of str or a +-
%% STR index -> STR index STR[index] T/F
/IsEndingTerm { IsEndingExpr { true } { dup dup 43 eq exch 45 eq or } ifelse } def
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% expr is ended by end of str or */
%% STR index -> STR index STR[index] T/F
/IsEndingFactor { IsEndingTerm { true } { dup dup 42 eq exch 47 eq or } ifelse } def
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% expr is ended by end of str or ^
%% STR index -> STR index STR[index] T/F
/IsEndingPower { IsEndingFactor { true } { dup 94 eq } ifelse } def
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% STR index -> STR index STR[index]
/NextNonBlankChar { { dup Strlen eq { 0 exit } if 2 copy get dup neBlkChar { exit } if pop 1 add } loop } bind def
/neBlkChar { dup 32 ne exch dup 10 ne exch 9 ne and and } bind def
%%%%%%%%%%%%%%%%%%%%%%%%
%% DEBUG
/BRK {false} def
/BRKtrue {/BRK true def} def
/BRKStop {BRK {BRKtoto} if } def
/BRKEvalStop {BRK exch if } def
/BRKBRK2true {BRK {BRK2true} if } def
/BRK2 {false} def
/BRK2true {/BRK2 true def} def
/BRK2Stop {BRK2 {BRK2toto} if } def/BRK {false} def
end
%
%-------------------------------------------------------------------------------%
%
/tx@AlgToPs 12 dict def tx@AlgToPs begin
%
%% algExpr -> PSVector
/AlgToPs { tx@CoreAnalyzerDict begin InitParser AnalyzeListOfE pop pop EndingSequence end } def
/EndingSequence { ExpressionVector aload length /end cvx exch 1 add array astore } def
/InitParser { /ExpressionVector [ /tx@AddMathFunc cvx /begin cvx ] def dup length /Strlen exch def 0 } def
/Strlen 0 def
/EvalListOfExpr {} def%
/EvalNumber {%
    ReadNumber  cvr /ExpressionVector ExpressionVector aload length dup 3 add -1 roll cvx
    exch 1 add array astore def NextNonBlankChar pop } def
/EvalAddSub {%
  /ExpressionVector ExpressionVector aload length dup 5 add -1 roll
  43 eq { /add } { /sub } ifelse cvx exch 1 add array astore def
} def
/EvalMulDiv {%
  /ExpressionVector ExpressionVector aload length dup 5 add -1 roll
  42 eq { /mul } { /div } ifelse cvx exch 1 add array astore def
} def
/EvalPower {%
  /ExpressionVector ExpressionVector aload length dup 5 add -1 roll
  pop /exp cvx exch 1 add array astore def
} def
/EvalLiteral {%
  ReadLiteral
  dup 40 eq%%% there is an open par -> function call
  { pop 2 index
    dup (Sum) eq { EvalSum }
    { dup (IfTE) eq { EvalCond }
      { dup (Derive) eq { pop EvalDerive }
        { pop 1 add NextNonBlankChar pop AnalyzeListOfE 2 index TrigoFunc
          /ExpressionVector ExpressionVector aload length dup 5 add -1 roll cvn cvx
          exch 1 add array astore def 1 add NextNonBlankChar pop } ifelse } ifelse} ifelse }
  { /ExpressionVector ExpressionVector aload length dup 6 add -1 roll cvn cvx exch 1 add array astore def
    dup 91 eq%%% there is an open bracket -> vector element
    { pop 1 add NextNonBlankChar pop AnalyzeExpr
      /ExpressionVector ExpressionVector aload length /cvi cvx exch /get cvx exch 2 add array astore def 1 add }
    { pop NextNonBlankChar pop }
    ifelse}
  ifelse
} def
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% the derive function : Derive(n,f(x))
%% firstparindex lastparindex ->
/EvalDerive {
  %% manage the function descripiton
  1 add ReadNumber 3 1 roll NextNonBlankChar
  44 ne { ANALYZER_ERROR_missing_second_comma_in_Sum } if
  1 add NextNonBlankChar pop
  3 -1 roll cvi
  dup 0 eq
  { pop AnalyzeExpr 3 -1 roll pop 1 add }
  { 1 sub 3 1 roll (x)  exch tx@Derive begin DeriveIndexed end 4 -1 roll
    { (x) tx@Derive begin Derive end } repeat
    ExpressionVector exch /ExpressionVector [] def
    AlgToPs aload length
    /ExpressionVector 1 index 3 add -1 roll aload length dup 3 add -1 roll  /l2 exch def /l1 exch def
    l1 l2 add 1 add l2 neg roll l1 l2 add array astore def 3 -1 roll pop 1 add
    1 index length /Strlen exch def } ifelse
} def
/EvalSum {%
  pop 1 add NextNonBlankChar pop
  %% read the variable name
  ReadLiteral pop NextNonBlankChar
  44 ne { ANALYZER_ERROR_missing_first_comma_in_Sum } if
  %% read the initial value
  1 add NextNonBlankChar pop ReadNumber cvi 3 1 roll
  2 copy get 44 ne { ANALYZER_ERROR_missing_second_comma_in_Sum } if
  %% read the increment value
  1 add NextNonBlankChar pop ReadNumber cvi 3 1 roll
  2 copy get 44 ne { ANALYZER_ERROR_missing_second_comma_in_Sum } if
  %% read the limit value
  1 add NextNonBlankChar pop ReadNumber cvi 3 1 roll
  2 copy get 44 ne { ANALYZER_ERROR_missing_second_comma_in_Sum } if
  /ExpressionVector ExpressionVector aload length dup 7 add -3 roll 0 4 1 roll
  5 -1 roll 4 add array astore def
  %% keep ExpressionVector for later and create a new one for internal Sum computation
  ExpressionVector 3 1 roll /ExpressionVector [ 6 -1 roll cvn /exch cvx /def cvx ] def
  1 add NextNonBlankChar pop AnalyzeExpr
  %% add each term
  /ExpressionVector ExpressionVector aload length 1 add /add cvx exch array astore def
  /ExpressionVector 4 -1 roll aload length ExpressionVector cvx /for cvx 3 -1 roll 2 add
  array astore def 3 -1 roll pop 1 add
} def
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Convert to radians if trigo function call
%% (name) ->
/TrigoFunc {
  dup (cos) eq 1 index (sin) eq or exch (tan) eq or
  { /ExpressionVector ExpressionVector aload length Pi /div cvx 180 /mul cvx 5 -1 roll 4 add
    array astore def
  } if
} def
/EvalCond {%
  pop 1 add AnalyzeCond NextNonBlankChar
  44 ne { ANALYZER_ERROR_missing_first_comma_in_IfTE } if
  ExpressionVector 3 1 roll /ExpressionVector [] def
  1 add AnalyzeExpr ExpressionVector 3 1 roll /ExpressionVector [] def
  NextNonBlankChar 44 ne { ANALYZER_ERROR_missing_second_comma_in_IfTE } if
  1 add AnalyzeExpr
  NextNonBlankChar 41 ne { ANALYZER_ERROR_missing_ending parenthesis_in_IfTE } if
  ExpressionVector
  /ExpressionVector 6 -1 roll aload length dup
  6 add -1 roll cvx exch dup 4 add -1 roll cvx /ifelse cvx 3 -1 roll 3 add array astore def
  1 add 3 -1 roll pop
} def
%% CondOp STR index
/EvalCondOp {%
  3 -1 roll
  dup (=) eq  { /eq } {%
  dup (<) eq  { /lt } {%
  dup (>) eq  { /gt } {%
  dup (>=) eq { /ge } {%
  dup (<=) eq { /ge } {%
  dup (!=) eq { /ne } { ERROR_non_valid_conditional_operator }
  ifelse } ifelse } ifelse } ifelse } ifelse } ifelse
  cvx exch pop
  /ExpressionVector ExpressionVector aload length dup 3 add -1 roll exch 1 add array astore def } def
/EvalUnaryOp {
  3 -1 roll 45 eq { /ExpressionVector ExpressionVector aload length /neg cvx exch 1 add array astore def } if
} def
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% H O O K S
/AnalyzePreHook {} bind def
/PreEvalHook {} bind def
/AnalyzeListOfEPostHook {} bind def
/AnalyzePostHook {} def
/RollOp { 3 1 roll } bind def
end   %tx@CoreAnalyzerDict
%
%--------------------------------------------------------------------%
%
/tx@Derive 41 dict def tx@Derive begin
%%increase ^^ for each function added
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% algExpr variable -> PSVector
/Derive {%
  10240 string 3 1 roll 0 3 1 roll
  /Variable exch def
  tx@CoreAnalyzerDict begin InitParser AnalyzeListOfE end
} def
/Strlen 0 def
/InitParser { dup length /Strlen exch def 0 } def
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% algExpr variable index -> PSVector
/DeriveIndexed {%
  3 1 roll 10240 string 3 1 roll 0 3 1 roll
  /Variable exch def
  tx@CoreAnalyzerDict begin InitParser pop 4 -1 roll AnalyzeExpr 4 -2 roll pop pop 4 -2 roll exch pop end
} def
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% (u,v)'=-(u',v')
/EvalListOfExpr {%
  4 2 roll 2 copy 9 -1 roll dup length 4 1 roll putinterval add AddPipe
           2 copy 7 -1 roll dup length 4 1 roll putinterval add
  6 -2 roll pop pop
  2 copy pop 0 6 2 roll GetIntervalNewStr 5 1 roll 2 copy 0 exch getinterval 6 1 roll } def
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% (-u)'=-(u')
/EvalUnaryOp {
  4 -2 roll 4 index (0) eq
  { (0) StrConcat 7 -1 roll pop }
  { 7 -1 roll 45 eq
    { AddSub AddOpPar true } { false } ifelse
    3 1 roll 5 index StrConcat 3 -1 roll { AddClPar } if } ifelse
  2 copy pop 0 6 2 roll GetIntervalNewStr
  7 -2 roll pop pop 2 index 6 index dup 4 index exch sub getinterval exch 6 2 roll
} def
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% (number)'=0
/EvalNumber { ReadNumber (0) 6 2 roll } def
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% (u+v)'=u'+v'
/EvalAddSub {%
  7 index dup (0) eq
  { pop true }%% du=0 nothing added
  { dup length exch 5 index 5 index 3 -1 roll putinterval 4 -1 roll add 3 1 roll false }
  ifelse
  5 index dup (0) eq
  { pop { (0) } { 4 -2 roll 2 copy pop 0  6 2 roll GetIntervalNewStr } ifelse }%%dv=0
  { exch
    { 5 -2 roll 7 index 45 eq { AddSub } if false } %%nothing yet added
    { 5 -2 roll 7 index 43 eq%%something yet added
      { AddAdd false } { AddSub AddOpPar true } ifelse }
    ifelse 11 1 roll
    3 -1 roll StrConcat 10 -1 roll { AddClPar } if
    2 copy pop 0 6 2 roll GetIntervalNewStr }
  ifelse
  mark 11 -5 roll cleartomark 2 index 6 index dup 4 index exch sub getinterval exch 6 2 roll
} def
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% (u*v)' or (u/v)'
/EvalMulDiv { 6 index 42 eq {EvalMul} {EvalDiv} ifelse } def
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% (u*v)'=u'*v+u*v'
/EvalMul {%
  4 -2 roll 7 index dup (0) eq
  { pop false }%%du=0
  { (1) eq%%du=1
    { false }
    { AddOpPar 7 index StrConcat AddClPar AddMul AddOpPar true } ifelse
    3 1 roll 6 index StrConcat 3 -1 roll { AddClPar } if
    true }%%du!=0
  ifelse
  5 1 roll 5 index (0) eq
  { 5 -1 roll not { (0) StrConcat } if }%%dv=0
  { 5 -1 roll { AddAdd } if
    4 index (1) eq
    { 8 index StrConcat }
    { AddOpPar 8 index StrConcat AddClPar AddMul AddOpPar 4 index StrConcat AddClPar }
    ifelse
  }%%dv!=0
  ifelse
  2 copy pop 0 6 2 roll GetIntervalNewStr
  mark 11 -5 roll cleartomark 2 index 6 index dup 4 index exch sub getinterval exch 6 2 roll
} def
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% (u/v)'=(u'*v-u*v')/v^2
/EvalDiv {%
  4 -2 roll
  4 index (0) eq%%dv=0 -> u'/v
  { 7 index (0) eq { (0) StrConcat } { AddOpPar 7 index StrConcat AddClPar AddDiv 5 index StrConcat } ifelse }
  { 7 index dup (0) eq
    { pop }%%du=0
    { (1) eq%%du=1
      { false }
      { AddOpPar 7 index StrConcat AddClPar AddMul AddOpPar true } ifelse
      3 1 roll 6 index StrConcat 3 -1 roll { AddClPar } if}%%du!=0
    ifelse
      AddSub
      4 index (1) eq
      { 8 index StrConcat }
      { AddOpPar 8 index StrConcat AddClPar AddMul AddOpPar 4 index StrConcat AddClPar }
      ifelse
    %}%%dv!=0
    2 copy GetIntervalNewStr 3 1 roll pop 0 AddOpPar 3 -1 roll StrConcat AddClPar
    AddDiv AddOpPar 5 index StrConcat AddClPar 2 copy (^2) putinterval 2 add }
  ifelse
  2 copy pop 0 6 2 roll GetIntervalNewStr
  mark 11 -5 roll cleartomark 2 index 6 index dup 4 index exch sub getinterval exch 6 2 roll
} def
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% str1 index str2 -> str1 index
/StrConcat { dup length 4 2 roll 2 copy 6 -1 roll putinterval 3 -1 roll add } bind def
/GetIntervalNewStr { 0 exch getinterval dup length string copy } bind def
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% (u^v)'=(u^v)'=u'vu^(v-1)+v'u^(v)ln(u)
/EvalPower {%
  4 -2 roll 7 index (0) eq
  {%%if du=0 then (u^v)'=v'ln(u)u^v
    4 index (0) eq
    { (0) StrConcat }%%if dv=0 then (u^v)'=0
    { 4 index (1) ne { AddOpPar 4 index StrConcat (\)*) StrConcat } if
      8 index (e) ne { (ln\() StrConcat 8 index StrConcat (\)*) StrConcat } if
      AddOpPar 8 index StrConcat (\)^\() StrConcat 5 index StrConcat AddClPar } ifelse
  }
  {%%du!=0
    4 index (0) eq
    {%%if dv=0 then (u^v)'=vu'u^(v-1)
      5 index dup IsStrNumber
      { dup (0) eq
        { StrConcat }
        { dup dup (1) eq exch (1.0) eq or
          { StrConcat  }
          { StrConcat
            7 index dup (1) ne exch (1.0) ne and%%%dr 09102006 insert du if <> 1
            { (*\() StrConcat 7 index StrConcat (\)) StrConcat } if%%%dr 09102006
            (*\() StrConcat 8 index StrConcat (\)) StrConcat
            5 index  dup dup (2) eq exch (2.0) eq or
            { pop } { cvr 1 sub 20 string cvs 3 1 roll (^) StrConcat 3 -1 roll StrConcat } ifelse } ifelse } ifelse }
      { pop AddOpPar 5 index StrConcat (\)*\() StrConcat 8 index StrConcat (\)^\() StrConcat
        5 index StrConcat (-1\)) StrConcat } ifelse
    }
    {%%if dv!=0 and du!=0 then (u^v)'=u'vu^(v-1)+v'u^(v)ln(u)
      7 index (1) ne { AddOpPar 7 index StrConcat (\)*) StrConcat } if
      AddOpPar 5 index StrConcat (\)*\() StrConcat
      8 index StrConcat (\)^\() StrConcat
      5 index StrConcat (-1\)+\() StrConcat
      4 index (1) ne { 4 index StrConcat (\)*\() StrConcat } if
      8 index StrConcat (\)^\() StrConcat
      5 index StrConcat (\)*ln\() StrConcat
      8 index StrConcat AddClPar
    } ifelse
  } ifelse
  2 copy pop 0 6 2 roll GetIntervalNewStr
  mark 11 -5 roll cleartomark 2 index 6 index dup 4 index exch sub getinterval exch 6 2 roll
} def
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% str -> true/false
/IsStrNumber {%
  true exch
  { dup 48 lt exch dup 57 gt 3 -1 roll or
    exch dup 46 ne%%.
    exch dup 43 ne%%+
    exch 45 ne%%-
    and and and { pop false } if } forall
} def
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% literal switch -> func call, vector, variables
/EvalLiteral {%
  ReadLiteral dup 40 eq%%% there is an open par -> function call
  { pop (EvalFunc_             ) 9 4 index StrConcat 0 exch getinterval cvn cvx exec }
  { dup 91 eq%%% there is an open bracket -> vector element
    { ERROR_vector_not_yet_implemented }
    { pop EvalVariable }
    ifelse }
  ifelse
} def
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% first last parpos Expr[first:parpos-1] ->
/EvalVariable { 2 index Variable eq { (1) } { (0) } ifelse 4 -1 roll exch 6 2 roll } def
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% (f(u))'=u'f'(u)
/EvalFunc {
  4 2 roll 4 index (1) ne
  { AddOpPar 4 index StrConcat (\)*) StrConcat } if
  (Eval             ) 4 8 index StrConcat 0 exch getinterval cvn cvx exec
  2 copy pop 0 6 2 roll GetIntervalNewStr
  mark 9 -3 roll cleartomark 2 index 6 index dup 4 index exch sub getinterval exch 6 2 roll
} def
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Func derivative -> Eval<func>
/EvalFunc_sin {%
  PreCommonFunc
  { (cos\() StrConcat 5 index StrConcat AddClPar } if
  PostCommonFunc } def
/EvalFunc_cos {%
  PreCommonFunc
  { (\(-sin\() StrConcat 5 index StrConcat (\)\)) StrConcat } if
  PostCommonFunc } def
/EvalFunc_tan {%
  PreCommonFunc
  {  dup 0 eq { (1) StrConcat } { 1 sub } ifelse  (/cos\() StrConcat 5 index StrConcat (\)^2) StrConcat } if
  PostCommonFunc } def
/EvalFunc_asin {%
  PreCommonFunc
  { (1/sqrt\(1-\() StrConcat 5 index StrConcat (\)^2\)\)) StrConcat } if
  PostCommonFunc } def
/EvalFunc_acos {%
  PreCommonFunc
  { (-1/sqrt\(1-\() StrConcat 5 index StrConcat (\)^2\)\)) StrConcat } if
  PostCommonFunc } def
/EvalFunc_atg {%
  PreCommonFunc
  { (1/\(1+\() StrConcat 5 index StrConcat (\)^2\)\)) StrConcat } if
  PostCommonFunc } def
/EvalFunc_ln {%
  PreCommonFunc
  {  dup 0 eq { (1) StrConcat } { 1 sub } ifelse (/\() StrConcat 5 index StrConcat AddClPar } if
  PostCommonFunc } def
/EvalFunc_exp {%
  PreCommonFunc
  {  (exp\() StrConcat 5 index StrConcat AddClPar } if
  PostCommonFunc } def
/EvalFunc_sqrt {%
  PreCommonFunc
  { dup 0 eq { (1) StrConcat } { 1 sub } ifelse (/\(2*sqrt\() StrConcat 5 index StrConcat (\)\)) StrConcat } if
  PostCommonFunc } def
/EvalFunc_Fact {%
  PreCommonFunc { ERROR_no_variable_expression_in_Fact } if
  PostCommonFunc } def
/EvalFunc_sh {%
  PreCommonFunc
  { (ch\() StrConcat 5 index StrConcat AddClPar } if
  PostCommonFunc } def
/EvalFunc_ch {%
  PreCommonFunc
  { (sh\() StrConcat 5 index StrConcat AddClPar } if
  PostCommonFunc } def
/EvalFunc_th {%
  PreCommonFunc
  {  dup 0 eq { (1) StrConcat } { 1 sub } ifelse  (/ch\() StrConcat 5 index StrConcat (\)^2) StrConcat } if
  PostCommonFunc } def
/EvalFunc_Argsh {%
  PreCommonFunc
  { (1/sqrt\(1+\() StrConcat 5 index StrConcat (\)^2\)\)) StrConcat } if
  PostCommonFunc } def
/EvalFunc_Argch {%
  PreCommonFunc
  { (1/sqrt\(\() StrConcat 5 index StrConcat (\)^2-1\)\)) StrConcat } if
  PostCommonFunc } def
/EvalFunc_Argth {%
  PreCommonFunc
  { (1/\(1-\() StrConcat 5 index StrConcat (\)^2\)\)) StrConcat } if
  PostCommonFunc } def
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
/PreCommonFunc {
  1 add NextNonBlankChar pop 3 -1 roll 5 1 roll AnalyzeExpr 1 add NextNonBlankChar pop
  4 2 roll 4 index (0) eq
  { (0) StrConcat false }
  { 4 index (1)  ne { AddOpPar 4 index StrConcat (\)*) StrConcat } if true } ifelse
} def
/PostCommonFunc {
  2 copy pop 0 6 2 roll GetIntervalNewStr
  mark 9 -3 roll cleartomark 2 index 6 index dup 4 index exch sub getinterval exch 6 2 roll
} def
/EvalFunc_Derive {%
  1 add ReadNumber cvi 1 add dup cvr log 1 add cvi string cvs
  4 -1 roll pop 5 1 roll 1 add NextNonBlankChar pop AnalyzeExpr 1 add
  4 -2 roll (Derive\() StrConcat 7 -1 roll StrConcat (,) StrConcat 6 -1 roll StrConcat AddClPar
  2 copy pop 0 6 2 roll GetIntervalNewStr 6 -1 roll pop 2 index 6 index dup 4 index exch sub getinterval
  exch 6 2 roll } def
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% literal switch -> func call, vector, variables
/EvalFunc_Sum {%
  1 add NextNonBlankChar pop
  %% read the variable name
  ReadLiteral pop 3 -1 roll pop NextNonBlankChar
  44 ne { ANALYZER_ERROR_missing_first_comma_in_Sum } if
  %% read the initial value
  1 add NextNonBlankChar pop ReadNumber pop
  2 copy get 44 ne { ANALYZER_ERROR_missing_second_comma_in_Sum } if
  %% read the increment value
  1 add NextNonBlankChar pop ReadNumber pop
  2 copy get 44 ne { ANALYZER_ERROR_missing_third_comma_in_Sum } if
  %% read the limit value
  1 add NextNonBlankChar pop ReadNumber pop
  2 copy get 44 ne { ANALYZER_ERROR_missing_fourth_comma_in_Sum } if
  1 add NextNonBlankChar pop dup 6 1 roll 3 -1 roll pop AnalyzeExpr 1 add NextNonBlankChar pop
  4 -2 roll 3 index 8 index dup 9 index exch sub getinterval StrConcat
  4 index StrConcat AddClPar
  2 copy pop 0 6 2 roll GetIntervalNewStr
  mark 9 -3 roll cleartomark 2 index 6 index dup 4 index exch sub getinterval exch 6 2 roll
} def
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% literal switch -> func call, vector, variables
/EvalFunc_IfTE {%
  3 -1 roll pop 1 add NextNonBlankChar pop SkipCond
  NextNonBlankChar
  44 ne { ANALYZER_ERROR_missing_first_comma_in_IfTE } if
  1 add NextNonBlankChar pop dup 5 1 roll
  AnalyzeExpr NextNonBlankChar
  44 ne { ANALYZER_ERROR_missing_second_comma_in_IfTE } if
  1 add NextNonBlankChar pop
  AnalyzeExpr 1 add NextNonBlankChar pop
  4 -2 roll 3 index 10 index dup 11 index exch sub getinterval StrConcat
  6 index StrConcat (,) StrConcat 4 index StrConcat AddClPar
  2 copy pop 0 6 2 roll GetIntervalNewStr
  mark 11 -5 roll cleartomark 2 index 6 index dup 4 index exch sub getinterval exch 6 2 roll
} def
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% advance in str until a comma is found (no error detection!)
%% str index -> str index'
/SkipCond { { 1 add 2 copy get 44 eq {exit } if } loop } bind def
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Convert to radians if trigo function call
%% (name) ->
/TrigoFunc {
  dup (cos) eq 1 index (sin) eq or exch (tan) eq or
  { /ExpressionVector ExpressionVector aload length Pi /div cvx 180 /mul cvx 5 -1 roll 4 add
    array astore def
  } if
} def
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% No derivative for condition....
/EvalCondOp { 3 -1 roll pop } bind def
/PutIntervalOneAdd {putinterval 1 add} bind def
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Add open parenthesis in string at the given index
%% str index -> str index+1
/AddOpPar {2 copy (\() PutIntervalOneAdd} bind def
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Add close parenthesis in string at the given index
%% str index -> str index+1
/AddClPar {2 copy (\)) PutIntervalOneAdd} bind def
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Add 0 in string at the given index
%% str index -> str index+1
/AddZero {2 copy (0) PutIntervalOneAdd} bind def
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Add open parenthesis in string at the given index
%% str index -> str index+1
/AddMul {2 copy (*) PutIntervalOneAdd} bind def
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Add open parenthesis in string at the given index
%% str index -> str index+1
/AddDiv {2 copy (/) PutIntervalOneAdd} bind def
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Add a plus sign in string at the given index
%% str index -> str index+1
/AddAdd {2 copy (+) PutIntervalOneAdd} bind def
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Add a minus sign in string at the given index
%% str index -> str index+1
/AddSub {2 copy (-) PutIntervalOneAdd} bind def
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Add a pipe sign in string at the given index
%% str index -> str index+1
/AddPipe {2 copy (|) PutIntervalOneAdd} bind def
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% H O O K S
/AnalyzePreHook { dup 5 1 roll } bind def
/PreEvalHook {} def
/AnalyzePostHook { 7 -1 roll pop } bind def
/AnalyzeListOfEPostHook { 6 -1 roll mark 6 1 roll cleartomark } bind def
/RollOp { 5 1 roll } bind def
end%%%tx@CoreAnalyzerDict
/tx@AddMathFunc 12 dict def tx@AddMathFunc begin
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% NEW FUNC
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% function arcsine in radians asin(x)=atan(x/sqrt(1-x^2))
%% x -> theta
/asin {%
  dup abs 1 gt { EQDFasinrangeerror  } if
  dup dup dup mul 1 exch sub sqrt atan exch 0 lt { 360 sub } if DegtoRad
} def
%% function arccosine in radians acos(x)=atan(sqrt(1-x^2)/x)
%% x -> theta
/acos {%
  dup abs 1 gt { EQDFacosrangeerror  } if
  dup dup mul 1 exch sub sqrt exch atan DegtoRad
} def
%% function arctangent in radians
%% x -> theta
/atg { 1 atan dup 90 gt { 360 sub } if DegtoRad } bind def
%% HYPERBOLIC FUNCTIONS
/sh { dup Ex exch neg Ex sub 2 div } def
/ch { dup Ex exch neg Ex add 2 div } def
/th { dup sh exch ch div } def
/Argsh { dup dup mul 1 add sqrt add ln } def
/Argch { dup dup mul 1 sub sqrt add ln } def
/Argth { dup 1 add exch 1 exch sub div ln 2 div } def
%% modified exponential funtion for 0
%% x n -> x^n
/Exp { dup 0 eq { pop pop 1 } { exp } ifelse } bind def
%% modified exponential funtion for 0
%% x -> e^x
/Ex { Euler exch exp } bind def
%%
%% factorial function
%% n -> n!
/Fact { 1 exch 2 exch 1 exch { mul } for } bind def
/fact { Fact } bind def
end

% END pstricks.pro

%%EndProcSet
%%BeginProcSet: pst-dots.pro 0 0
% $Id: pst-dots.pro 11 2008-01-24 13:37:27Z herbert $
%
%% PostScript prologue for pstricks.tex.
%% Version 2.01,  2008/04/18
%%
%% For distribution, see pstricks.tex.
%%
%% Timothy Van Zandt <tvz@Princeton.EDU>
%%
%% This program can be redistributed and/or modified under the terms
%% of the LaTeX Project Public License Distributed from CTAN archives
%% in directory macros/latex/base/lppl.txt.
%%
%% Modified by Etienne Riga  - Dec. 16, 1999
%% Modified by Etienne Riga  - 2005/01/01 (er)
%% to add /Diamond, /SolidDiamond and /BoldDiamond
%% Modified by Herbert Voss (hv) - 2008/04/17 
%
10 dict dup begin                       % hold local
  /FontType 3 def
  /FontMatrix [.001 0 0 .001 0 0] def
  /FontBBox [-571.5 -742.5 571.5 742.5] def
%  /FontBBox [-1000 -1000 1000 1000] def  % See end of file in /BuildGlyph
  /Encoding 256 array def
  0 1 255 {Encoding exch /.notdef put} for % fill the array with /.notdef
  Encoding                                 % replace with given dot names
    dup (b) 0 get /Bullet put              % get the numerical position of b in ASCII
%                                          % and save /Bullet at this place in Encoding 
    dup (c) 0 get /Circle put
    dup (C) 0 get /BoldCircle put       % 67
    dup (u) 0 get /SolidTriangle put
    dup (t) 0 get /Triangle put
    dup (T) 0 get /BoldTriangle put
    dup (r) 0 get /SolidSquare put
    dup (s) 0 get /Square put
    dup (S) 0 get /BoldSquare put
    dup (q) 0 get /SolidPentagon put
    dup (p) 0 get /Pentagon put
    dup (P) 0 get /BoldPentagon put
%%%               
    dup (k) 0 get /Asterisk put
    dup (K) 0 get /BoldAsterisk put
    dup (J) 0 get /SolidAsterisk put
    dup (h) 0 get /Hexagon put
    dup (H) 0 get /BoldHexagon put
    dup (G) 0 get /SolidHexagon put
    dup (f) 0 get /Octogon put          % 2008-04-18 hv
    dup (F) 0 get /BoldOctogon put      % 2008-04-18 hv
    dup (g) 0 get /SolidOctogon put     % 2008-04-18 hv
    dup (a) 0 get /Add put
    dup (A) 0 get /BoldAdd put          % 65
    dup (x) 0 get /Mul put
    dup (X) 0 get /BoldMul put
    dup (m) 0 get /Oplus put
    dup (M) 0 get /BOplus put
    dup (e) 0 get /SolidOplus put
    dup (n) 0 get /Otimes put
    dup (N) 0 get /BOtimes put
    dup (E) 0 get /SolidOtimes put
    dup (i) 0 get /Bar put
    dup (I) 0 get /BoldBar put
    dup (l) 0 get /SolidDiamond put
    dup (d) 0 get /Diamond put
        (D) 0 get /BoldDiamond put
%%%  
/CharProcs 47 dict def
CharProcs begin
  /CirclePath {0 0 500 0 360 arc closepath} def
  /Bullet {CirclePath fill} def
  /Circle {CirclePath .9 .9 scale CirclePath eofill} def
  /BoldCircle {CirclePath .8 .8 scale CirclePath eofill} def
  /TrianglePath {0 660 moveto -571.5 -330 lineto 571.5 -330 lineto closepath} def
  /SolidTriangle {TrianglePath fill} def
  /Triangle {TrianglePath .85 .85 scale TrianglePath eofill} def
  /BoldTriangle {TrianglePath .7 .7 scale TrianglePath eofill} def
  /SquarePath {-450 450 moveto 450 450 lineto 450 -450 lineto -450 -450 lineto closepath} def
  /SolidSquare {SquarePath fill} def
  /Square {SquarePath .89 .89 scale SquarePath eofill} def
  /BoldSquare {SquarePath .78 .78 scale SquarePath eofill} def
  /PentagonPath {
    -337.8 -465 moveto 337.8 -465 lineto 546.6 177.6 lineto
    0 574.7 lineto -546.6 177.6 lineto closepath
  } def
  /SolidPentagon {PentagonPath fill} def
  /Pentagon {PentagonPath .89 .89 scale PentagonPath eofill} def
  /BoldPentagon {PentagonPath .78 .78 scale PentagonPath eofill} def
%-------------- hv begin 2004/07/25   from: er 2003/03/24
  /HexagonPath {
    0 550 moveto -476 275 lineto -476 -275 lineto
    0 -550 lineto 476 -275 lineto 476 275 lineto closepath
  } def
  /SolidHexagon {HexagonPath fill} def
  /Hexagon {HexagonPath .89 .89 scale HexagonPath eofill} def
  /BoldHexagon {HexagonPath .79 .79 scale HexagonPath eofill} def
%                                       2008-04-18 hv
  /OctogonPath {
    228 550 moveto 7 { -456 0 rlineto 45 rotate } repeat 
    closepath
  } def 
  /SolidOctogon { OctogonPath fill                             } def
  /Octogon {      OctogonPath .89 .89 scale OctogonPath eofill } def
  /BoldOctogon {  OctogonPath .79 .79 scale OctogonPath eofill } def
%
  /AsteriskPath {
    20 0 moveto 10 250 180 500 0 500 curveto
    -180 500 -10 250 -20 0 curveto closepath
  } def
  /Asterisk {
    AsteriskPath 60 rotate AsteriskPath 60 rotate AsteriskPath
    60 rotate AsteriskPath 60 rotate AsteriskPath 60 rotate AsteriskPath fill
  } def
%
  /Basterp {50 250 220 500 0 500 curveto -220 500 -50 250 -50 30 cos 100 mul curveto} def
  /BoldAsteriskPath {
    50 30 cos 100 mul moveto  Basterp
    60 rotate Basterp 60 rotate Basterp
    60 rotate Basterp 60 rotate Basterp
    60 rotate Basterp closepath
  } def
  /BoldAsterisk {BoldAsteriskPath fill} def
  /SolidAsterisk {CirclePath .9 .9 scale BoldAsteriskPath eofill} def
  /CrossPath {
    40 550 moveto -40 550 lineto -40 40 lineto -550 40 lineto
    -550 -40 lineto -40 -40 lineto -40 -550 lineto 40 -550 lineto 
    40 -40 lineto 550 -40 lineto 550 40 lineto 40 40 lineto closepath
  } def
  /BoldCrossPath {80 550 moveto -80 550 lineto -80 80 lineto -550 80 lineto
    -550 -80 lineto -80 -80 lineto -80 -550 lineto 80 -550 lineto 
    80 -80 lineto 550 -80 lineto 550 80 lineto 80 80 lineto closepath
  } def
  /Add {CrossPath fill} def
  /Mul {45 rotate CrossPath fill} def
  /BoldAdd {BoldCrossPath fill} def
  /BoldMul {45 rotate BoldCrossPath fill} def
  /Oplus {CirclePath .9 .9 scale CirclePath eofill .775 .775 scale CrossPath fill } def 
  /SolidOplus {CirclePath .775 .775 scale BoldCrossPath eofill} def 
  /BOplus {CirclePath .8 .8 scale CirclePath eofill .775 .775 scale BoldCrossPath fill} def 
  /Otimes {CirclePath .9 .9 scale CirclePath eofill 45 rotate .775 .775 scale CrossPath fill} def 
  /BOtimes {CirclePath .8 .8 scale CirclePath eofill 45 rotate .775 .775 scale BoldCrossPath fill } def 
  /SolidOtimes {CirclePath 45 rotate .775 .775 scale BoldCrossPath eofill} def 
  /BarPath {40 660 moveto -40 660 lineto -40 -660 lineto 40 -660 lineto closepath} def
  /Bar {BarPath fill} def
  /BoldBarPath {80 660 moveto -80 660 lineto -80 -660 lineto 80 -660 lineto closepath} def
  /BoldBar {BoldBarPath fill} def
  /DiamondPath {0 742.5 moveto -428.5 0 lineto 0 -742.5 lineto 428.5 0 lineto closepath} def
  /SolidDiamond {DiamondPath fill} def
  /Diamond {DiamondPath .865 .865 scale DiamondPath eofill} def
  /BoldDiamond {DiamondPath .73 .73 scale DiamondPath eofill} def
%%%
  /.notdef { } def
end
%
/BuildGlyph {
  exch
  begin                 
%  Metrics 1 index get exec 0
    0 0
%      BBoxes 3 index get exec
    -1000 -1000 1000 1000
%     -571.5 -742.5 571.5 742.5
    setcachedevice
    CharProcs begin load exec end
  end
} def
%
/BuildChar {
  1 index /Encoding get exch get
  1 index /BuildGlyph get exec
} bind def

end
/PSTricksDotFont exch definefont pop

%% end

%%EndProcSet
%%BeginProcSet: pst-node.pro 0 0
%!PS
% PostScript prologue for pst-node.tex.
% Version 97 patch 1, 97/05/09.
% For distribution, see pstricks.tex.
%
/tx@NodeDict 400 dict def tx@NodeDict begin
tx@Dict begin 
 /T /translate load def 
end
/NewNode { % on stack: { x y } boolean N@name type InitXnode 
  gsave 
  /next ED                      % { x y } boolean N@name type  
  dict dup                      % { x y } boolean N@name dict dict
  3 1 roll def                  % { x y } boolean dict N@name dict def
  exch { dup 3 1 roll def } if  % { x y } dict boolean
  begin                         % { x y } dict begin
  tx@Dict begin 
    STV CP T exec               % set scaling
  end 
  /NodeMtrx CM def              % save CM
  next                          % InitXNode
  end
  grestore 
} def
%
/NewNode2 { % on stack:  x y  N@name type 
  gsave 
  dict dup                      %  x y  N@name dict dict
  3 1 roll def                  %  x y  dict N@name dict def
  begin                         %  x y  dict begin
  tx@Dict begin 
    STV CP T                    % set scaling
  end 
  /NodeMtrx CM def              % save CM
  /Y ED /X ED 
  /NodePos { NodeSep Cos mul NodeSep Sin mul } def
  end
  grestore 
} def
%
/InitPnode { 
  /Y ED /X ED 
  /NodePos { NodeSep Cos mul NodeSep Sin mul } def
} def
%
/InitCnode { 
  /r ED /Y ED /X ED 
  /NodePos { NodeSep r add dup Cos mul exch Sin mul } def 
} def
%
/GetRnodePos { Cos 0 gt { /dx r NodeSep add def } { /dx l NodeSep sub def
} ifelse Sin 0 gt { /dy u NodeSep add def } { /dy d NodeSep sub def }
ifelse dx Sin mul abs dy Cos mul abs gt { dy Cos mul Sin div dy } { dx
dup Sin mul Cos Div } ifelse } def
/InitRnode { /Y ED /X ED X sub /r ED /l X neg def Y add neg /d ED Y sub
/u ED /NodePos { GetRnodePos } def } def
/DiaNodePos { w h mul w Sin mul abs h Cos mul abs add Div NodeSep add dup
Cos mul exch Sin mul } def
/TriNodePos { Sin s lt { d NodeSep sub dup Cos mul Sin Div exch } { w h
mul w Sin mul h Cos abs mul add Div NodeSep add dup Cos mul exch Sin mul
} ifelse } def
/InitTriNode { sub 2 div exch 2 div exch 2 copy T 2 copy 4 index index /d
ED pop pop pop pop -90 mul rotate /NodeMtrx CM def /X 0 def /Y 0 def d
sub abs neg /d ED d add /h ED 2 div h mul h d sub Div /w ED /s d w Atan
sin def /NodePos { TriNodePos } def } def
/OvalNodePos { /ww w NodeSep add def /hh h NodeSep add def Sin ww mul Cos
hh mul Atan dup cos ww mul exch sin hh mul } def
/GetCenter { begin X Y NodeMtrx transform CM itransform end } def
%
/XYPos { dup sin exch cos Do /Cos ED /Sin ED /Dist ED Cos 0 gt { Dist
  Dist Sin mul Cos div } { Cos 0 lt { Dist neg Dist Sin mul Cos div neg }
  { 0 Dist Sin mul } ifelse } ifelse Do 
} def
/GetEdge { dup 0 eq { pop begin 1 0 NodeMtrx dtransform CM idtransform
  exch atan sub dup sin /Sin ED cos /Cos ED /NodeSep ED NodePos NodeMtrx
  dtransform CM idtransform end } { 1 eq {{exch}} {{}} ifelse /Do ED pop
  XYPos } ifelse 
} def
/AddOffset { 1 index 0 eq { pop pop } { 2 copy 5 2 roll cos mul add 4 1
roll sin mul sub exch } ifelse } def
/GetEdgeA { NodeSepA AngleA NodeA NodeSepTypeA GetEdge OffsetA AngleA
AddOffset yA add /yA1 ED xA add /xA1 ED } def
/GetEdgeB { NodeSepB AngleB NodeB NodeSepTypeB GetEdge OffsetB AngleB
AddOffset yB add /yB1 ED xB add /xB1 ED } def
/GetArmA { ArmTypeA 0 eq { /xA2 ArmA AngleA cos mul xA1 add def /yA2 ArmA
AngleA sin mul yA1 add def } { ArmTypeA 1 eq {{exch}} {{}} ifelse /Do ED
ArmA AngleA XYPos OffsetA AngleA AddOffset yA add /yA2 ED xA add /xA2 ED
} ifelse } def
/GetArmB { ArmTypeB 0 eq { /xB2 ArmB AngleB cos mul xB1 add def /yB2 ArmB
AngleB sin mul yB1 add def } { ArmTypeB 1 eq {{exch}} {{}} ifelse /Do ED
ArmB AngleB XYPos OffsetB AngleB AddOffset yB add /yB2 ED xB add /xB2 ED
} ifelse } def
/InitNC { 
  /b ED /a ED % second and first node
  /NodeSepTypeB ED /NodeSepTypeA ED 
  /NodeSepB ED /NodeSepA ED 
  /OffsetB ED /OffsetA ED 
  tx@NodeDict a known tx@NodeDict b known and dup { 
    /NodeA a load def 
    /NodeB b load def 
    NodeA GetCenter /yA ED /xA ED 
    NodeB GetCenter /yB ED /xB ED } if 
} def
%
/LPutLine { 4 copy 3 -1 roll sub neg 3 1 roll sub Atan /NAngle ED 1 t sub
mul 3 1 roll 1 t sub mul 4 1 roll t mul add /Y ED t mul add /X ED } def
/LPutLines { mark LPutVar counttomark 2 div 1 sub /n ED t floor dup n gt
{ pop n 1 sub /t 1 def } { dup t sub neg /t ED } ifelse cvi 2 mul { pop
} repeat LPutLine cleartomark } def
/BezierMidpoint { /y3 ED /x3 ED /y2 ED /x2 ED /y1 ED /x1 ED /y0 ED /x0 ED
/t ED /cx x1 x0 sub 3 mul def /cy y1 y0 sub 3 mul def /bx x2 x1 sub 3
mul cx sub def /by y2 y1 sub 3 mul cy sub def /ax x3 x0 sub cx sub bx
sub def /ay y3 y0 sub cy sub by sub def ax t 3 exp mul bx t t mul mul
add cx t mul add x0 add ay t 3 exp mul by t t mul mul add cy t mul add
y0 add 3 ay t t mul mul mul 2 by t mul mul add cy add 3 ax t t mul mul
mul 2 bx t mul mul add cx add atan /NAngle ED /Y ED /X ED } def
/HPosBegin { yB yA ge { /t 1 t sub def } if /Y yB yA sub t mul yA add def
} def
/HPosEnd { /X Y yyA sub yyB yyA sub Div xxB xxA sub mul xxA add def
/NAngle yyB yyA sub xxB xxA sub Atan def } def
/HPutLine { HPosBegin /yyA ED /xxA ED /yyB ED /xxB ED HPosEnd  } def
/HPutLines { HPosBegin yB yA ge { /check { le } def } { /check { ge } def
} ifelse /xxA xA def /yyA yA def mark xB yB LPutVar { dup Y check { exit
} { /yyA ED /xxA ED } ifelse } loop /yyB ED /xxB ED cleartomark HPosEnd 
} def
/VPosBegin { xB xA lt { /t 1 t sub def } if /X xB xA sub t mul xA add def
} def
/VPosEnd { /Y X xxA sub xxB xxA sub Div yyB yyA sub mul yyA add def
/NAngle yyB yyA sub xxB xxA sub Atan def } def
/VPutLine { VPosBegin /yyA ED /xxA ED /yyB ED /xxB ED VPosEnd  } def
/VPutLines { VPosBegin xB xA ge { /check { le } def } { /check { ge } def
} ifelse /xxA xA def /yyA yA def mark xB yB LPutVar { 1 index X check {
exit } { /yyA ED /xxA ED } ifelse } loop /yyB ED /xxB ED cleartomark
VPosEnd  } def
/HPutCurve { gsave newpath /SaveLPutVar /LPutVar load def LPutVar 8 -2
roll moveto curveto flattenpath /LPutVar [ {} {} {} {} pathforall ] cvx
def grestore exec /LPutVar /SaveLPutVar load def } def
/NCCoor { /AngleA yB yA sub xB xA sub Atan def /AngleB AngleA 180 add def
GetEdgeA GetEdgeB /LPutVar [ xB1 yB1 xA1 yA1 ] cvx def /LPutPos {
LPutVar LPutLine } def /HPutPos { LPutVar HPutLine } def /VPutPos {
LPutVar VPutLine } def LPutVar } def
/NCLine { NCCoor tx@Dict begin ArrowA CP 4 2 roll ArrowB lineto pop pop
end } def
/NCLines { false NArray n 0 eq { NCLine } { 2 copy yA sub exch xA sub
Atan /AngleA ED n 2 mul dup index exch index yB sub exch xB sub Atan
/AngleB ED GetEdgeA GetEdgeB /LPutVar [ xB1 yB1 n 2 mul 4 add 4 roll xA1
yA1 ] cvx def mark LPutVar tx@Dict begin false Line end /LPutPos {
LPutLines } def /HPutPos { HPutLines } def /VPutPos { VPutLines } def }
ifelse } def
/NCCurve { GetEdgeA GetEdgeB xA1 xB1 sub yA1 yB1 sub Pyth 2 div dup 3 -1
roll mul /ArmA ED mul /ArmB ED /ArmTypeA 0 def /ArmTypeB 0 def GetArmA
GetArmB xA2 yA2 xA1 yA1 tx@Dict begin ArrowA end xB2 yB2 xB1 yB1 tx@Dict
begin ArrowB end curveto /LPutVar [ xA1 yA1 xA2 yA2 xB2 yB2 xB1 yB1 ]
cvx def /LPutPos { t LPutVar BezierMidpoint } def /HPutPos { { HPutLines
} HPutCurve } def /VPutPos { { VPutLines } HPutCurve } def } def
%
/NCAngles { 
  GetEdgeA GetEdgeB GetArmA GetArmB 
  /mtrx AngleA matrix rotate def 
  xA2 yA2 mtrx transform pop 
  xB2 yB2 mtrx transform exch pop 
  mtrx itransform 
  /y0 ED /x0 ED 
  mark ArmB 0 ne { xB1 yB1 } if 
  xB2 yB2 x0 y0 xA2 yA2 
  ArmA 0 ne { xA1 yA1 } if 
  tx@Dict begin false Line end 
  /LPutVar [ xB1 yB1 xB2 yB2 x0 y0 xA2 yA2 xA1 yA1 ] cvx def 
  /LPutPos { LPutLines } def
  /HPutPos { HPutLines } def 
  /VPutPos { VPutLines } def } def
%
/NCAngle { GetEdgeA GetEdgeB GetArmB /mtrx AngleA matrix rotate def xB2
yB2 mtrx itransform pop xA1 yA1 mtrx itransform exch pop mtrx transform
/y0 ED /x0 ED mark ArmB 0 ne { xB1 yB1 } if xB2 yB2 x0 y0 xA1 yA1
tx@Dict begin false Line end /LPutVar [ xB1 yB1 xB2 yB2 x0 y0 xA1 yA1 ]
cvx def /LPutPos { LPutLines } def /HPutPos { HPutLines } def /VPutPos {
VPutLines } def } def
/NCBar { GetEdgeA GetEdgeB GetArmA GetArmB /mtrx AngleA matrix rotate def
xA2 yA2 mtrx itransform pop xB2 yB2 mtrx itransform pop sub dup 0 mtrx
transform 3 -1 roll 0 gt { /yB2 exch yB2 add def /xB2 exch xB2 add def }
{ /yA2 exch neg yA2 add def /xA2 exch neg xA2 add def } ifelse mark ArmB
0 ne { xB1 yB1 } if xB2 yB2 xA2 yA2 ArmA 0 ne { xA1 yA1 } if tx@Dict
begin false Line end /LPutVar [ xB1 yB1 xB2 yB2 xA2 yA2 xA1 yA1 ] cvx
def /LPutPos { LPutLines } def /HPutPos { HPutLines } def /VPutPos {
VPutLines } def } def
/NCDiag { GetEdgeA GetEdgeB GetArmA GetArmB mark ArmB 0 ne { xB1 yB1 } if
xB2 yB2 xA2 yA2 ArmA 0 ne { xA1 yA1 } if tx@Dict begin false Line end
/LPutVar [ xB1 yB1 xB2 yB2 xA2 yA2 xA1 yA1 ] cvx def /LPutPos {
LPutLines } def /HPutPos { HPutLines } def /VPutPos { VPutLines } def }
def
/NCDiagg { GetEdgeA GetArmA yB yA2 sub xB xA2 sub Atan 180 add /AngleB ED
GetEdgeB mark xB1 yB1 xA2 yA2 ArmA 0 ne { xA1 yA1 } if tx@Dict begin
false Line end /LPutVar [ xB1 yB1 xA2 yA2 xA1 yA1 ] cvx def /LPutPos {
LPutLines } def /HPutPos { HPutLines } def /VPutPos { VPutLines } def }
def
/NCLoop { GetEdgeA GetEdgeB GetArmA GetArmB /mtrx AngleA matrix rotate
def xA2 yA2 mtrx transform loopsize add /yA3 ED /xA3 ED /xB3 xB2 yB2
mtrx transform pop def xB3 yA3 mtrx itransform /yB3 ED /xB3 ED xA3 yA3
mtrx itransform /yA3 ED /xA3 ED mark ArmB 0 ne { xB1 yB1 } if xB2 yB2
xB3 yB3 xA3 yA3 xA2 yA2 ArmA 0 ne { xA1 yA1 } if tx@Dict begin false
Line end /LPutVar [ xB1 yB1 xB2 yB2 xB3 yB3 xA3 yA3 xA2 yA2 xA1 yA1 ]
cvx def /LPutPos { LPutLines } def /HPutPos { HPutLines } def /VPutPos {
VPutLines } def } def
% DG/SR modification begin - May 9, 1997 - Patch 1
%/NCCircle { 0 0 NodesepA nodeA \tx@GetEdge pop xA sub 2 div dup 2 exp r
%r mul sub abs sqrt atan 2 mul /a ED r AngleA 90 add PtoC yA add exch xA add
%exch 2 copy /LPutVar [ 4 2 roll r AngleA ] cvx def /LPutPos { LPutVar t 360
%mul add dup 5 1 roll 90 sub \tx@PtoC 3 -1 roll add /Y ED add /X ED /NAngle ED
/NCCircle { NodeSepA 0 NodeA 0 GetEdge pop 2 div dup 2 exp r
r mul sub abs sqrt atan 2 mul /a ED r AngleA 90 add PtoC yA add exch xA add
exch 2 copy /LPutVar [ 4 2 roll r AngleA ] cvx def /LPutPos { LPutVar t 360
mul add dup 5 1 roll 90 sub PtoC 3 -1 roll add /Y ED add /X ED /NAngle ED
% DG/SR modification end
} def /HPutPos { LPutPos } def /VPutPos { LPutPos } def r AngleA 90 sub a add
AngleA 270 add a sub tx@Dict begin /angleB ED /angleA ED /r ED /c 57.2957 r
Div def /y ED /x ED } def
/NCBox { /d ED /h ED /AngleB yB yA sub xB xA sub Atan def /AngleA AngleB
180 add def GetEdgeA GetEdgeB /dx d AngleB sin mul def /dy d AngleB cos
mul neg def /hx h AngleB sin mul neg def /hy h AngleB cos mul def
/LPutVar [ xA1 hx add yA1 hy add xB1 hx add yB1 hy add xB1 dx add yB1 dy
add xA1 dx add yA1 dy add ] cvx def /LPutPos { LPutLines } def /HPutPos
{ xB yB xA yA LPutLine } def /VPutPos { HPutPos } def mark LPutVar
tx@Dict begin false Polygon end } def
/NCArcBox { /l ED neg /d ED /h ED /a ED /AngleA yB yA sub xB xA sub Atan
def /AngleB AngleA 180 add def /tA AngleA a sub 90 add def /tB tA a 2
mul add def /r xB xA sub tA cos tB cos sub Div dup 0 eq { pop 1 } if def
/x0 xA r tA cos mul add def /y0 yA r tA sin mul add def /c 57.2958 r div
def /AngleA AngleA a sub 180 add def /AngleB AngleB a add 180 add def
GetEdgeA GetEdgeB /AngleA tA 180 add yA yA1 sub xA xA1 sub Pyth c mul
sub def /AngleB tB 180 add yB yB1 sub xB xB1 sub Pyth c mul add def l 0
eq { x0 y0 r h add AngleA AngleB arc x0 y0 r d add AngleB AngleA arcn }
{ x0 y0 translate /tA AngleA l c mul add def /tB AngleB l c mul sub def
0 0 r h add tA tB arc r h add AngleB PtoC r d add AngleB PtoC 2 copy 6 2
roll l arcto 4 { pop } repeat r d add tB PtoC l arcto 4 { pop } repeat 0
0 r d add tB tA arcn r d add AngleA PtoC r h add AngleA PtoC 2 copy 6 2
roll l arcto 4 { pop } repeat r h add tA PtoC l arcto 4 { pop } repeat }
ifelse closepath /LPutVar [ x0 y0 r AngleA AngleB h d ] cvx def /LPutPos
{ LPutVar /d ED /h ED /AngleB ED /AngleA ED /r ED /y0 ED /x0 ED t 1 le {
r h add AngleA 1 t sub mul AngleB t mul add dup 90 add /NAngle ED PtoC }
{ t 2 lt { /NAngle AngleB 180 add def r 2 t sub h mul t 1 sub d mul add
add AngleB PtoC } { t 3 lt { r d add AngleB 3 t sub mul AngleA 2 t sub
mul add dup 90 sub /NAngle ED PtoC } { /NAngle AngleA 180 add def r 4 t
sub d mul t 3 sub h mul add add AngleA PtoC } ifelse } ifelse } ifelse
y0 add /Y ED x0 add /X ED } def /HPutPos { LPutPos } def /VPutPos {
LPutPos } def } def
/Tfan { /AngleA yB yA sub xB xA sub Atan def GetEdgeA w xA1 xB sub yA1 yB
sub Pyth Pyth w Div CLW 2 div mul 2 div dup AngleA sin mul yA1 add /yA1
ED AngleA cos mul xA1 add /xA1 ED /LPutVar [ xA1 yA1 m { xB w add yB xB
w sub yB } { xB yB w sub xB yB w add } ifelse xA1 yA1 ] cvx def /LPutPos
{ LPutLines } def /VPutPos@ { LPutVar flag { 8 4 roll pop pop pop pop }
{ pop pop pop pop 4 2 roll } ifelse } def /VPutPos { VPutPos@ VPutLine }
def /HPutPos { VPutPos@ HPutLine } def mark LPutVar tx@Dict begin
/ArrowA { moveto } def /ArrowB { } def false Line closepath end } def

/LPutCoor { NAngle tx@Dict begin /NAngle ED end gsave CM STV CP Y sub neg
exch X sub neg exch moveto setmatrix CP grestore } def

/LPut { tx@NodeDict /LPutPos known { LPutPos } { CP /Y ED /X ED /NAngle 0
def } ifelse LPutCoor  } def
/HPutAdjust { Sin Cos mul 0 eq { 0 } { d Cos mul Sin div flag not { neg }
if h Cos mul Sin div flag { neg } if 2 copy gt { pop } { exch pop }
ifelse } ifelse s add flag { r add neg } { l add } ifelse X add /X ED }
def
/VPutAdjust { Sin Cos mul 0 eq { 0 } { l Sin mul Cos div flag { neg } if
r Sin mul Cos div flag not { neg } if 2 copy gt { pop } { exch pop }
ifelse } ifelse s add flag { d add } { h add neg } ifelse Y add /Y ED }
def
end
% END pst-node.pro

%%EndProcSet
%%BeginProcSet: solides.pro 0 0
%!
% PostScript prologue for pst-solides3d.tex.
% Version 4.03, 2008/07/12
%
%% COPYRIGHT 2008 by Jean-Paul Vignault
%%
%% This program can be redistributed and/or modified under the terms
%% of the LaTeX Project Public License Distributed from CTAN
%% archives in directory macros/latex/base/lppl.txt.
%
/SolidesDict 100 dict def
/SolidesbisDict 100 dict def
SolidesDict begin

%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% %% les variables globales gerees par PSTricks %%
%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% %% les lignes dessous sont a decommenter si l on veut utiliser le
%% %% fichier solides.pro independamment du package PSTricks
%% /Dobs 20 def
%% /THETA 20 def
%% /PHI 50 def
%% /Decran 30 def
%% /XpointVue {Dobs Cos1Cos2 mul} def
%% /YpointVue {Dobs Sin1Cos2 mul} def
%% /ZpointVue {Dobs Sin2 mul} def
%% /xunit 28.14 def
%% /solidhollow false def
%% /solidbiface false def
%% /xunit 28.45 def
%% /tracelignedeniveau? true def
%% /hauteurlignedeniveau 1 def
%% /couleurlignedeniveau {rouge} def
%% /linewidthlignedeniveau 4 def
%% /solidgrid true def
/aretescachees true def
/defaultsolidmode 2 def
/Stroke { strokeopacity .setopacityalpha stroke } def
/Fill { fillopacity .setopacityalpha fill } def

%% variables globales specifiques a PSTricks
%% /activationgestioncouleurs true def
/xmin -10 def
/xmax 10 def
/ymin -10 def
/ymax 10 def

/fillstyle {} def
/startest false def
/cm {} def
/cm_1 {} def
/yunit {xunit} def
/angle_repere 90 def

/hadjust 2.5 def
/vadjust 2.5 def
/pl@n-en-cours false def

/pointilles {
   [6.25 3.75] 1.25 setdash
} def
/stockcurrentcpath {} def
/newarrowpath {} def
/chaine 15 string def

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% choix d une fonte accentuee pour le .ps %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
/ReEncode { exch findfont
dup length dict begin { 1 index /FID eq {pop pop} {def} ifelse
}forall /Encoding ISOLatin1Encoding def currentdict end definefont
pop }bind def
/Font /Times-Roman /ISOfont ReEncode /ISOfont def
%Font findfont 10 scalefont setfont

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% extrait de color.pro pour pouvoir recuperer ses couleurs %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
/GreenYellow{0.15 0 0.69 0 setcmykcolor}def
/Yellow{0 0 1 0 setcmykcolor}def
/Goldenrod{0 0.10 0.84 0 setcmykcolor}def
/Dandelion{0 0.29 0.84 0 setcmykcolor}def
/Apricot{0 0.32 0.52 0 setcmykcolor}def
/Peach{0 0.50 0.70 0 setcmykcolor}def
/Melon{0 0.46 0.50 0 setcmykcolor}def
/YellowOrange{0 0.42 1 0 setcmykcolor}def
/Orange{0 0.61 0.87 0 setcmykcolor}def
/BurntOrange{0 0.51 1 0 setcmykcolor}def
/Bittersweet{0 0.75 1 0.24 setcmykcolor}def
/RedOrange{0 0.77 0.87 0 setcmykcolor}def
/Mahogany{0 0.85 0.87 0.35 setcmykcolor}def
/Maroon{0 0.87 0.68 0.32 setcmykcolor}def
/BrickRed{0 0.89 0.94 0.28 setcmykcolor}def
/Red{0 1 1 0 setcmykcolor}def
/OrangeRed{0 1 0.50 0 setcmykcolor}def
/RubineRed{0 1 0.13 0 setcmykcolor}def
/WildStrawberry{0 0.96 0.39 0 setcmykcolor}def
/Salmon{0 0.53 0.38 0 setcmykcolor}def
/CarnationPink{0 0.63 0 0 setcmykcolor}def
/Magenta{0 1 0 0 setcmykcolor}def
/VioletRed{0 0.81 0 0 setcmykcolor}def
/Rhodamine{0 0.82 0 0 setcmykcolor}def
/Mulberry{0.34 0.90 0 0.02 setcmykcolor}def
/RedViolet{0.07 0.90 0 0.34 setcmykcolor}def
/Fuchsia{0.47 0.91 0 0.08 setcmykcolor}def
/Lavender{0 0.48 0 0 setcmykcolor}def
/Thistle{0.12 0.59 0 0 setcmykcolor}def
/Orchid{0.32 0.64 0 0 setcmykcolor}def
/DarkOrchid{0.40 0.80 0.20 0 setcmykcolor}def
/Purple{0.45 0.86 0 0 setcmykcolor}def
/Plum{0.50 1 0 0 setcmykcolor}def
/Violet{0.79 0.88 0 0 setcmykcolor}def
/RoyalPurple{0.75 0.90 0 0 setcmykcolor}def
/BlueViolet{0.86 0.91 0 0.04 setcmykcolor}def
/Periwinkle{0.57 0.55 0 0 setcmykcolor}def
/CadetBlue{0.62 0.57 0.23 0 setcmykcolor}def
/CornflowerBlue{0.65 0.13 0 0 setcmykcolor}def
/MidnightBlue{0.98 0.13 0 0.43 setcmykcolor}def
/NavyBlue{0.94 0.54 0 0 setcmykcolor}def
/RoyalBlue{1 0.50 0 0 setcmykcolor}def
/Blue{1 1 0 0 setcmykcolor}def
/Cerulean{0.94 0.11 0 0 setcmykcolor}def
/Cyan{1 0 0 0 setcmykcolor}def
/ProcessBlue{0.96 0 0 0 setcmykcolor}def
/SkyBlue{0.62 0 0.12 0 setcmykcolor}def
/Turquoise{0.85 0 0.20 0 setcmykcolor}def
/TealBlue{0.86 0 0.34 0.02 setcmykcolor}def
/Aquamarine{0.82 0 0.30 0 setcmykcolor}def
/BlueGreen{0.85 0 0.33 0 setcmykcolor}def
/Emerald{1 0 0.50 0 setcmykcolor}def
/JungleGreen{0.99 0 0.52 0 setcmykcolor}def
/SeaGreen{0.69 0 0.50 0 setcmykcolor}def
/Green{1 0 1 0 setcmykcolor}def
/ForestGreen{0.91 0 0.88 0.12 setcmykcolor}def
/PineGreen{0.92 0 0.59 0.25 setcmykcolor}def
/LimeGreen{0.50 0 1 0 setcmykcolor}def
/YellowGreen{0.44 0 0.74 0 setcmykcolor}def
/SpringGreen{0.26 0 0.76 0 setcmykcolor}def
/OliveGreen{0.64 0 0.95 0.40 setcmykcolor}def
/RawSienna{0 0.72 1 0.45 setcmykcolor}def
/Sepia{0 0.83 1 0.70 setcmykcolor}def
/Brown{0 0.81 1 0.60 setcmykcolor}def
/Tan{0.14 0.42 0.56 0 setcmykcolor}def
/Gray{0 0 0 0.50 setcmykcolor}def
/Black{0 0 0 1 setcmykcolor}def
/White{0 0 0 0 setcmykcolor}def
%% fin de l extrait color.pro

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%             autres couleurs                        %%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

/bleu {0 0 1 setrgbcolor} def
/rouge {1 0 0 setrgbcolor} def
/vert {0 .5 0 setrgbcolor} def
/gris {.4 .4 .4 setrgbcolor} def
/jaune {1 1 0 setrgbcolor} def
/noir {0 0 0 setrgbcolor} def
/blanc {1 1 1 setrgbcolor} def
/orange {1 .65 0 setrgbcolor} def
/rose {1 .01 .58  setrgbcolor} def
/cyan {1 0 0 0 setcmykcolor} def
/magenta {0 1 0 0 setcmykcolor} def

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%             definition du point de vue             %%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% pour la 3D conventionnelle
%% Dony : graphisme scientifique : page 187
%% Editeur : Masson

%% calcul des coefficients de la matrice
%% de transformation
/Sin1 {THETA sin} def
/Sin2 {PHI sin} def
/Cos1 {THETA cos} def
/Cos2 {PHI cos} def
/Cos1Sin2 {Cos1 Sin2 mul} def
/Sin1Sin2 {Sin1 Sin2 mul} def
/Cos1Cos2 {Cos1 Cos2 mul} def
/Sin1Cos2 {Sin1 Cos2 mul} def

/3dto2d {
6 dict begin
   /Zcote exch def
   /Yordonnee exch def
   /Xabscisse exch def
   /xObservateur
      Xabscisse Sin1 mul neg Yordonnee Cos1 mul add
   def
   /yObservateur
      Xabscisse Cos1Sin2 mul neg Yordonnee Sin1Sin2 mul sub Zcote Cos2
      mul add
   def
   /zObservateur
      Xabscisse neg Cos1Cos2 mul Yordonnee Sin1Cos2 mul sub Zcote Sin2
      mul sub Dobs add
   def
   %% maintenant on depose les resultats sur la pile
   Decran xObservateur mul zObservateur div cm
   Decran yObservateur mul zObservateur div cm
end
} def

/getpointVue {
   XpointVue
   YpointVue
   ZpointVue
} def

/GetCamPos {
   getpointVue
} def

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%         jps modifie pour PSTricks                  %%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

/solid {continu} def
/dashed {pointilles} def

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%             geometrie basique                      %%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%% syntaxe~: [x1 y1 ... xn yn] ligne
/ligne {
gsave
   newpath
      dup 0 getp smoveto
      ligne_
      starfill
   Stroke
grestore
} def

%% syntaxe~: [x1 y1 ... xn yn] ligne_
/ligne_ {
   reversep
   aload length 2 idiv
   {
      slineto
   } repeat
} def

%% syntaxe~: [x1 y1 ... xn yn] polygone
/polygone* {
1 dict begin
   /startest {true} def
   polygone
end
} def

/polygone_ {
   newpath
      aload length 2 idiv
      3 copy pop
      smoveto
      {
         slineto
      } repeat
   closepath
} def

/polygone {
   gsave
      polygone_
      starfill
      currentlinewidth 0 eq {} {Stroke} ifelse
   grestore
} def

%% syntaxe : x y point
/point {
gsave
   1 setlinecap
   newpath
      smoveto
      0 0 rlineto
      5 setlinewidth
   Stroke
grestore
} def

/point_ {
   1 setlinecap
   5 setlinewidth
      smoveto
      0 0 rlineto
} def

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%                                                    %%%%
%%%%          insertion librairie jps                   %%%%
%%%%                                                    %%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%              le repere jps                         %%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

/sysatan {systemdict /atan get exec} def
/atan {2 copy 0 0 eqp {pop pop 0} {sysatan} ifelse} def
%%%%% ### AAAscale ###
%%%%%%%%%%%%%%%% les deplacements a l echelle %%%%%%%%%%%%%%%%%%%

 /v@ct_I {xunit 0} def
 /v@ct_J {angle_repere cos yunit mul angle_repere sin yunit mul} def

/xscale {} def
/yscale {} def

/xscale-1 {} def
/yscale-1 {} def

/gtransform {} def
/gtransform-1 {} def

/jtoppoint {
2 dict begin
   gtransform
   /y exch yscale def
   /x exch xscale def
   v@ct_I x mulv
   v@ct_J y mulv
   addv
end
} def

/rptojpoint {
   xtranslate ytranslate 
   3 1 roll         %% xA yB yA xB 
   4 1 roll         %% xB xA yB yA 
   sub neg 3 1 roll %% yB-yA xB xA 
   sub neg exch
   ptojpoint
} def

/rptoppoint {
   xtranslate ytranslate 
   3 1 roll         %% xA yB yA xB 
   4 1 roll         %% xB xA yB yA 
   sub neg 3 1 roll %% yB-yA xB xA 
   sub neg exch
} def

/ptojpoint {
4 dict begin
   /Y exch yscale-1 def
   /X exch xscale-1 def
   /y Y yunit angle_repere sin mul div def
   /x X y yunit mul angle_repere cos mul sub xunit div def
   x y
   gtransform-1
end
} def

/smoveto {
   jtoppoint
   moveto
} def

/srmoveto {
   jtoppoint
   rmoveto
} def

/slineto {
   jtoppoint
   lineto
} def

/srlineto {
   jtoppoint
   rlineto
} def

/stranslate {
   jtoppoint
   translate
} def

%%%%% ### fin insertion ###

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%            methodes numeriques                     %%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%%%%% ### solve2nddegre ###
%% syntaxe : a b c solve2nddegre --> x1 x2
/solve2nddegre {
5 dict begin
   /@c exch def
   /@b exch def
   /@a exch def
   /delt@ @b dup mul 4 @a mul @c mul sub def
   @b neg delt@ sqrt sub 2 @a mul div
   @b neg delt@ sqrt add 2 @a mul div
end
} def

%%%%% ### fin insertion ###

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%                  la 2D                             %%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%                  points                            %%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%%%%% ### tripointangle ###
%% syntaxe : A B C tripointangle --> angle ABC
/tripointangle {
9 dict begin
   /yC exch def
   /xC exch def
   /yB exch def
   /xB exch def
   /yA exch def
   /xA exch def
   /A {xA yA} def
   /B {xB yB} def
   /C {xC yC} def
   B C angle
   B A angle
   sub
end   
} def

%%%%% ### angle ###
%% syntaxe : A B angle
%% --> num, l'angle defini par le vecteur AB dans le repere orthonorme jps 
/angle {
   vecteur exch atan
   dup 180 gt 
      {360 sub}
   if
} def

%% syntaxe : A B pangle
%% --> num, l'angle defini par le vecteur AB dans le repere postscript
/pangle {
   jtoppoint exchp jtoppoint exchp vecteur exch atan
   dup 180 gt 
         {360 sub}
   if
} def

%%%%% ### setxrange ###
/setxrange {
   /xmax exch def
   /xmin exch def
} def

%%%%% ### setyrange ###
/setyrange {
   /ymax exch def
   /ymin exch def
} def

%%%%% ### defpoint ###
%% syntaxe : xA yA /A defpoint
/defpoint {
1 dict begin
   /t@mp@r@ire exch def
   [ 3 1 roll ] cvx t@mp@r@ire exch 
end def
} def

%%%%% ### milieu ###
%% syntaxe~: A B milieu 
/milieu {  
                %% xA yA xB yB
   3 -1 roll    %% xA xB yB yA 
   add 2 div    %% xA xB yM
   3 1 roll     %% yM xA xB 
   add 2 div    %% yM xM
   exch
} def

%%%%% ### parallelopoint ###
%% syntaxe : A B C parallelopoint --> point D, tel que ABCD parallelogramme
/parallelopoint {
11 dict begin
   /yC exch def
   /xC exch def
   /yB exch def
   /xB exch def
   /yA exch def
   /xA exch def
   /A {xA yA} def
   /B {xB yB} def
   /C {xC yC} def
   /d1 {A B C paral} def
   /d2 {B C A paral} def
   d1 d2 interdroite
end
} def

%%%%% ### translatepoint ###
%% syntaxe : A u translatepoint --> B image de A par la translation de vecteur u
/translatepoint {
   addv
} def

%%%%% ### rotatepoint ###
%% syntaxe : B A r rotatepoint --> C image de B par la rotation de centre A,
%% d'angle r (en degre)
%% En prenant les affixes des pts associes, il vient
%%    (zC - zA) = (zB-zA) e^(ir)
%% soit 
%%    zC = (zB-zA) e^(ir) + zA
/rotatepoint {     %% B, A, r
   5 copy          %% B, A, r, B, A, r
   cos 5 1 roll    %% B, A, r, cos r, B, A
   4 1 roll        %% B, A, r, cos r, yA, B, xA
   4 1 roll        %% B, A, r, cos r, A, B 
   vecteur         %% B, A, r, cos r, xB-xA, yB-yA
   4 -1 roll sin   %% B, A, cos r, xB-xA, yB-yA, sin r
   4 copy mul      %% B, A, cos r, xB-xA, yB-yA, sin r, cos r, xB-xA, (yB-yA) sin r
   7 1 roll mul    %% B, A, (yB-yA) sin r, cos r, xB-xA, yB-yA, sin r, cos r (xB-xA)
   5 1 roll        %% B, A, (yB-yA) sin r, cos r (xB-xA), cos r, xB-xA, yB-yA, sin r
   exch            %% B, A, (yB-yA) sin r, cos r (xB-xA), cos r, xB-xA, sin r, yB-yA
   4 -1 roll mul   %% B, A, (yB-yA) sin r, cos r (xB-xA), xB-xA, sin r, (yB-yA)cos r
   3 1 roll mul    %% B, A, (yB-yA) sin r, cos r (xB-xA), (yB-yA) cos r, (xB-xA) sin r
   add             %% B, A, (yB-yA) sin r, cos r (xB-xA), (yB-yA) cos r +(xB-xA) sin r
   3 1 roll        %% B, A, (yB-yA) cos r + (xB-xA) sin r, (yB-yA) sin r, cos r (xB-xA), 
   exch sub        %% B, A, (yB-yA) cos r + (xB-xA) sin r, cos r (xB-xA)-(yB-yA) sin r 
   exch            %% B, zA, (zB-zA) e^(ir)
   addv
   3 -1 roll pop
   3 -1 roll pop
} def

%%%%% ### hompoint ###
%% syntaxe : B A alpha hompoint -> le point A' tel que AA' = alpha AB
/hompoint {
   5 copy
   pop
   vecteur      %% vecteur BA
   3 -1 roll
   neg
   mulv   %% alpha x vecteur AB
   addv
   4 -1 roll
   4 -1 roll
   pop pop
} def

%%%%% ### orthoproj ###
%% syntaxe : A D orthoproj --> B, le projete orthogonal de A sur D
/orthoproj {
   6 -1 roll
   6 -1 roll            %% D A
   6 copy               %% D A D A
   7 -1 roll pop
   7 -1 roll pop        %% D D A
   perp 
   interdroite
} def

%% syntaxe : A projx --> le projete orthogonal de A sur Ox
/projx {
   pop 0
} def

%% syntaxe : A projy --> le projete orthogonal de A sur Oy
/projy {
   exch pop 0 exch
} def

%%%%% ### sympoint ###
%% syntaxe : A I sympoint --> point A', le symetrique de A par rapport
%% au point I
/sympoint {
   4 copy
   pop pop
   vecteur 
   -2 mulv
   addv
} def

%%%%% ### axesympoint ###
%% syntaxe : A D axesympoint --> point B, le symetrique de A par rapport
%% a la droite D
/axesympoint {
2 dict begin
   6 copy
   pop pop pop pop
   /yA exch def
   /xA exch def
   orthoproj 
   xA yA vecteur 
   -2 mulv
   xA yA addv
end   
} def

%%%%% ### cpoint ###
%% syntaxe : alpha C cpoint -> M, le point du cercle C correspondant a
%% l'angle alpha
/cpoint {           %% a, xI, yI, r 
1 dict begin
   dup              %% a, xI, yI, r, r
   5 -1 roll        %% xI, yI, r, r, a
   /alpha exch def  
   alpha cos mul    %% xI, yI, r, r cos a
   exch
   alpha sin mul    %% xI, yI, r cos a, r sin a
   3 -1 roll add    %% xI, r cos a, yI + r sin a
   3 1 roll         %% yI + r sin a, xI, r cos a, 
   add exch         %% xI + r cos a, yI + r sin a
end
} def

%%%%% ### xdpoint ###
%% x A B xdpoint : le point de la droite (AB) d'abscisse x
/xdpoint {
5 dict begin
   /pt2 defpoint
   /pt1 defpoint
   /x exch def
   /a pt1 pt2 coeffdir def
   /b pt1 pt2 ordorig def
   x dup a mul b add
end   
} def

%%%%% ### ydpoint ###
%% y A B ydpoint : le point de la droite (AB) d'ordonnee y
/ydpoint {
5 dict begin
   /pt2 defpoint
   /pt1 defpoint
   /y exch def
   pt1 pt2 verticale? 
      {
         pt1 pop y
      }
      {
         /a pt1 pt2 coeffdir def
         /b pt1 pt2 ordorig def
         y b sub a div y
      }
   ifelse
end   
} def

%%%%% ### ordonnepoints ###
%% syntaxe : xA yA xB yB ordonnepoints --> idem si yB>yA ou si yB=yA
%% avec xB>xA, sinon xB yB xA yA
/ordonnepoints {
   4 copy
   exch pop             %% ... xA, yA, yB
   lt                   %% yA < yB ?
      {pop}                     %% oui, c'est fini
      {                         %% non : yA >= yB
         pop 4 copy  
         exch pop               %% ... xA, yA, yB
         eq                     %% yA = yB ?
            {
               3 copy                   %% oui, yA = yB
               pop pop                  %% ... xA, xB
               le                       %% xA =< xB ?
                  {}                          %% oui, c'est fini
                  {                           %% non, on echange A et B
                     4 -1 roll
                     4 -1 roll
                  }
               ifelse
            }
            {                           %% non : yA < yB => on echange A et B
               pop
               4 -1 roll
               4 -1 roll
            }
         ifelse
      } 
   ifelse
} def

%%%%% ### distance ###
%% syntaxe~: A B distance
/distance {      %% xA yA xB yB
   vecteur       %% x y
   dup mul exch  %% y^2 x
   dup mul       %% y^2 x^2
   add
   sqrt
} def

%%%%% ### dup ###
/dupp {2 copy} def
/dupc {3 copy} def
/dupd {4 copy} def

%%%%% ### fin insertion ###
/interdroites {interdroite} def

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%                 vecteurs                           %%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%%%%% ### vecteur ###
%% syntaxe~: A B vecteur
/vecteur {
                %% xA yA xB yB 
   3 -1 roll    %% xA xB yB yA 
   sub          %% xA xB yB-yA 
   3 1 roll     %% yB-yA xA xB 
   exch sub     %% yB-yA xB-xA 
   exch
} def

%%%%% ### normalize ###
%% syntaxe : u normalize -> u / ||u||
/normalize {
2 dict begin
   /u defpoint
   /n u norme def
   u 1 n div mulv
end
} def

%%%%% ### addv ###
%% syntaxe : u v addv --> u+v
/addv {         %% xA yA xB yB
   3 1 roll     %% xA yB yA xB 
   4 1 roll     %% xB xA yB yA 
   add 3 1 roll %% yB+yA xB xA 
   add exch
} def

%%%%% ### subv ###
%% syntaxe : u v subv --> u - v
/subv { %% xA yA xB yB
   -1 mulv
   addv
} def

%%%%% ### mulv ###
%% syntaxe : u a mulv --> au
/mulv {   %% xA, yA, a
   dup          %% xA, yA, a, a
   3 1 roll     %% xA, a, yA, a
   mul 3 1 roll %% ayA, xA, a
   mul exch
} def

%%%%% ### scalprod ###
%% syntaxe : u v scalprod --> le produit scalaire de u par v
/scalprod {
2 dict begin
   /y' exch def
   exch 
   /y exch def
   mul y y' mul add
end
} def

%%%%% ### normal ###
%% syntaxe : u normal --> v tel u.v = 0
/normal {
   neg exch
} def

%%%%% ### norme ###
%% syntaxe : u norme --> |u|
/norme {
   dup mul
   exch
   dup mul
   add sqrt
} def

%%%%% ### oldarrow ###
%% syntaxe : A B oldarrow --> trace fleche en B, direction AB
/oldarrow {
4 dict begin
gsave
   /B defpoint
   /A defpoint
   oldarrowscale scale
   oldarrowangle rotate
   newpath 
   B smoveto
   A B vecteur normalize /u defpoint
   u neg exch /v defpoint
   u oldarrowpointe neg mulv rmoveto %% ainsi c'est la pointe qui est en (0, 0)
   %% le pt extremal arriere haut
      u oldarrowplume neg mulv        %% l'abscisse
      v oldarrow@ngle sin oldarrow@ngle cos div oldarrowplume mul mulv addv %% l'ordonnee
   rlineto
      u oldarrowplume oldarrowpointe add mulv
      v oldarrow@ngle sin oldarrow@ngle cos div oldarrowplume mul neg mulv addv
   rlineto 
      u oldarrowplume oldarrowpointe add neg mulv
      v oldarrow@ngle sin oldarrow@ngle cos div oldarrowplume mul neg mulv addv
   rlineto
   closepath Fill
grestore
end
} def

/oldarrowpointe {xunit 5 div} def
/oldarrowplume {xunit 10 div} def 
/oldarrow@ngle 45 def        
/oldarrowscale {1 1} def
/oldarrowangle 0 def     %% pour l'utilisateur

%%%%% ### drawvecteur ###
%% syntaxe : A B drawvecteur
/drawvecteur {
2 dict begin
   /B defpoint
   /A defpoint
   [A B] ligne
   A B oldarrow
end
} def

%%%%% ### orthovecteur ###
%% syntaxe : u orthovecteur --> v, vecteur orthogonal a u
/orthovecteur {
   neg exch
} def

%%%%% ### fin insertion ###

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%                  cercles                           %%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%%%%% ### defcercle ###
%% syntaxe : A r /d defcercle
/defcercle {
1 dict begin
   /t@mp@r@ire exch def
   [ 4 1 roll ] cvx t@mp@r@ire exch 
end def
} def

%%%%% ### interdroitecercle ###
%% intersection de la droite y = ax+b avec le cercle (x-x0)^2 + (y-y0)^2 = r^2
%% { --       b - y                   2          2           3
%% { |  x = - -----, y = (b + a x0 + a  y0 + (2 a  b y0 - 2 a  b x0 +
%% { --         a
%% 
%%       3          2  2    2  2    4  2    2   2    4   2             2
%%    2 a  x0 y0 - a  b  + a  r  + a  r  - a  y0  - a  x0 )^(1/2)) / (a  + 1)
%% 
%% 
%%    -- 
%%     |,
%%    -- 
%%     --       b - y                   2          2           3
%%     |  x = - -----, y = (b + a x0 + a  y0 - (2 a  b y0 - 2 a  b x0 +
%%     --         a
%% 
%%       3          2  2    2  2    4  2    2   2    4   2             2
%%    2 a  x0 y0 - a  b  + a  r  + a  r  - a  y0  - a  x0 )^(1/2)) / (a  + 1)
%% 
%%    -- }
%%     | }
%%    -- }

%% intersection de la droite x = a avec le cercle (x-x0)^2 + (y-y0)^2 = r^2
%%                              2    2     2 1/2
%% {[x = a, y = y0 + (2 a x0 - a  + r  - x0 )   ],
%% 
%%                                2    2     2 1/2
%%    [x = a, y = y0 - (2 a x0 - a  + r  - x0 )   ]}

%% intersection de la droite y = b avec le cercle (x-x0)^2 + (y-y0)^2 = r^2
%%                              2    2     2 1/2
%% {[y = b, x = x0 + (2 b y0 - b  + r  - y0 )   ],
%% 
%%                                2    2     2 1/2
%%    [y = b, x = x0 - (2 b y0 - b  + r  - y0 )   ]}

%% syntaxe : D I r interdroitecercle
/interdroitecercle {
16 dict begin
   /r exch def
   /y0 exch def
   /x0 exch def
   /yB exch def
   /xB exch def
   /yA exch def
   /xA exch def

   xA yA xB yB verticale?

   %% la droite est verticale
   {
      /xpt1 xA def
      /xpt2 xA def
      /quantite 
         2 xA mul x0 mul xA dup mul sub r dup mul add x0 dup mul sub sqrt
      def
      /ypt1
         y0 quantite add
      def
      /ypt2
         y0 quantite sub
      def
   }

   %% la droite n'est pas verticale
   {
      /a xA yA xB yB coeffdir def
      /b xA yA xB yB ordorig def

      0 a eq 
      %% la droite est horizontale
      {
         /quantite
            2 b mul y0 mul 
            b dup mul sub
            r dup mul add
            y0 dup mul sub
            sqrt
         def
         /xpt1 
            x0 quantite add
         def
         /xpt2 
            x0 quantite sub
         def
         /ypt1 b def
         /ypt2 b def
      } 

      %% la droite n'est pas horizontale
      {
         /quantite1 
            b 
            a x0 mul add
            a dup mul y0 mul add
         def
         /quantite2
            2 a dup mul mul b mul y0 mul 
            2 a 3 exp mul b mul x0 mul sub
            2 a 3 exp mul x0 mul y0 mul add
            a dup mul b dup mul mul sub
            a dup mul r dup mul mul add
            a 4 exp r dup mul mul add
            a dup mul y0 dup mul mul sub
            a 4 exp x0 dup mul mul sub 
            sqrt 
         def
         /quantite3 
            a dup mul 1 add 
         def
         /ypt1
            quantite1 quantite2 add quantite3 div
         def
         /xpt1 
            ypt1 b sub a div 
         def
         /ypt2
            quantite1 quantite2 sub quantite3 div
         def
         /xpt2 
            ypt2 b sub a div 
         def
      } 
      ifelse
   }
   ifelse
   
   xpt1 ypt1 
   xpt2 ypt2 
   ordonnepoints
end
} def

%%%%% ### intercercle ###
%% syntaxe : cerc1 cerc2 intercercle --> A B les points d'intersection
%% des 2 cercles, tries par 'ordonnepoints'
/intercercle {
12 dict begin
   /r2 exch def
   /y2 exch def
   /x2 exch def
   /r1 exch def
   /y1 exch def
   /x1 exch def

   %% on translate pour se ramener a (x1, y1) = (0, 0)
   x2 y2 x1 y1 subv
   /y2 exch def
   /x2 exch def

   %% on prepare l'equation du 2nd degre

%%                    2       2    2
%%   {y = RootOf((4 x2  + 4 y2 ) _Z
%% 
%%                  3        2              2       2            4
%%          + (-4 y2  - 4 r1~  y2 + 4 y2 r2~  - 4 x2  y2) _Z + x2
%% 
%%               4       2    2       2   2       2    2        2   2
%%          + r2~  - 2 y2  r2~  + 2 x2  y2  - 2 x2  r2~  - 2 r1~  x2
%% 
%%               4     4        2   2        2    2
%%          + r1~  + y2  + 2 r1~  y2  - 2 r1~  r2~ ), x = 1/2 (-2 y2
%% 
%%                     2       2    2
%%         RootOf((4 x2  + 4 y2 ) _Z
%% 
%%                  3        2              2       2            4
%%          + (-4 y2  - 4 r1~  y2 + 4 y2 r2~  - 4 x2  y2) _Z + x2
%% 
%%               4       2    2       2   2       2    2        2   2
%%          + r2~  - 2 y2  r2~  + 2 x2  y2  - 2 x2  r2~  - 2 r1~  x2
%% 
%%               4     4        2   2        2    2       2     2     2
%%          + r1~  + y2  + 2 r1~  y2  - 2 r1~  r2~ ) + r1~  + x2  + y2
%% 
%%               2
%%          - r2~ )/x2}

   %% coeff pour le degre 2
   /a 
      %%                    2       2    2
      %%   {y = RootOf((4 x2  + 4 y2 ) _Z
      4 x2 dup mul mul
      4 y2 dup mul mul add
   def

   %% coeff pour le degre 1
   %%
   /b 
      %%                    3        2              2       2        
      %%            + (-4 y2  - 4 r1~  y2 + 4 y2 r2~  - 4 x2  y2) _Z 
      -4 y2 3 exp mul
      4 r1 dup mul mul y2 mul sub
      4 r2 dup mul mul y2 mul add
      4 x2 dup mul mul y2 mul sub
   def

   %% coeff pour le degre 0
   %%
   /c {
      %%              4
      %%          + x2
      x2 4 exp
      %% 
      %%               4       2    2       2   2       2    2        2   2
      %%          + r2~  - 2 y2  r2~  + 2 x2  y2  - 2 x2  r2~  - 2 r1~  x2
      r2 4 exp add
      2 y2 dup mul mul r2 dup mul mul sub
      2 x2 dup mul mul y2 dup mul mul add
      2 x2 dup mul mul r2 dup mul mul sub
      2 x2 dup mul mul r1 dup mul mul sub
      %% 
      %%               4     4        2   2        2    2
      %%          + r1~  + y2  + 2 r1~  y2  - 2 r1~  r2~ )
      r1 4 exp add
      y2 4 exp add
      2 r1 dup mul mul y2 dup mul mul add
      2 r1 dup mul mul r2 dup mul mul sub
   } def

   a b c solve2nddegre
   /Y1 exch def
   /Y0 exch def
   
   /X0
      %% x = 1/2 (-2 y2  Y
      -2 y2 mul Y0 mul
      %% 
      %%        2     2     2
      %% + r1~  + x2  + y2
      r1 dup mul add
      x2 dup mul add
      y2 dup mul add
      %% 
      %%                 2
      %%            - r2~ )/x2}
      r2 dup mul sub
   
      2 x2 mul div
   def
   
   /X1
      %% x = 1/2 (-2 y2  Y
      -2 y2 mul Y1 mul
      %% 
      %%        2     2     2
      %% + r1~  + x2  + y2
      r1 dup mul add
      x2 dup mul add
      y2 dup mul add
      %% 
      %%                 2
      %%            - r2~ )/x2}
      r2 dup mul sub
   
      2 x2 mul div
   def

   %% on depose le resultat, en n'oubliant pas de retranslater en sens
   %% inverse

   X0 Y0 x1 y1 addv
   X1 Y1 x1 y1 addv
   ordonnepoints
end
} def

%%%%% ### ABcercle ###
%% syntaxe : A B C ABcercle --> le cercle passant par A, B, C
/ABcercle {
3 dict begin
   /@3 defpoint
   /@2 defpoint
   /@1 defpoint
   @1 @2 mediatrice
   @1 @3 mediatrice
   interdroite
   dupp
   @3 distance
end   
} def

%%%%% ### diamcercle ###
%% syntaxe : A B diamcercle --> le cercle de diametre [AB]
/diamcercle {
   4 copy
   distance 2 div
   5 1 roll 
   milieu
   3 -1 roll 
} def

%%%%% ### fin insertion ###

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%                  droites                           %%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%%%%% ### horizontale ###
%% syntaxe : y horizontale 
/horizontale {
1 dict begin
   /y exch def
   xmin y xmax y
end
} def

%%%%% ### coeffdir ###
%% syntaxe~: A B coeffdir
/coeffdir {
   vecteur exch div
} def

%%%%% ### ordorig ###
%% syntaxe : A B ordorig
%% attention, la droite est supposee ne pas etre verticale
/ordorig {
   /dr@ite 4 array def
   dr@ite 3 3 -1 roll put
   dr@ite 2 3 -1 roll put
   dr@ite 1 3 -1 roll put
   dr@ite 0 3 -1 roll put
   dr@ite aload pop coeffdir /c@eff exch def
   dr@ite aload pop pop pop  %% xA yA
   exch                      %% yA xA 
   c@eff mul neg add
} def

%%%%% ### verticale ###
%% syntaxe~: A B verticale?
/verticale? {
   pop 2 1 roll pop
   eq
} def

%% syntaxe : x verticale
/verticale {
1 dict begin
   /x exch def
   x ymin x ymax
end
} def

%%%%% ### droite ###
%% %% syntaxe : A B droite
%% /droite {
%% gsave
%% 6 dict begin
%%    /yB exch def
%%    /xB exch def
%%    /yA exch def
%%    /xA exch def
%%    xA yA xB yB
%%    eqp
%%       {}
%%       { 
%%          xA yA xB yB
%%       verticale?
%%       {
%%       newpath
%%          xA ymin smoveto
%%          xA ymax slineto
%%             stockcurrentcpath
%%       Stroke
%%       }
%%       {
%%       newpath
%%          /alpha xA yA xB yB coeffdir def
%%          /beta xA yA xB yB ordorig def
%%          xmin dup alpha mul beta add smoveto
%%          xmax dup alpha mul beta add slineto
%%             stockcurrentcpath
%%       Stroke
%%       }
%%       ifelse
%%       }
%%    ifelse
%% end
%% grestore
%% } def

%% syntaxe : A B droite
/droite {
gsave
6 dict begin
   /B defpoint
   /A defpoint
   A pop B pop eq {
      %% droite verticale
      newpath
         A pop ymin smoveto
         A pop ymax slineto
         stockcurrentcpath
      Stroke
   } {
      %% on cherche le point le + a gauche
      xmin A B xdpoint /C defpoint
      C exch pop ymin lt {
         %% trop a gauche
         ymin A B ydpoint /C defpoint
      } if
      C exch pop ymax gt {
         %% trop a gauche
         ymax A B ydpoint /C defpoint
      } if
      %% on cherche le point le + a droite
      xmax A B xdpoint /D defpoint
      D exch pop ymin lt {
         %% trop a droite
         ymin A B ydpoint /D defpoint
      } if
      D exch pop ymax gt {
         %% trop a gauche
         ymax A B ydpoint /D defpoint
      } if
      newpath
         C smoveto
         D slineto
         stockcurrentcpath
     Stroke
   } ifelse
end
grestore
} def

%%%%% ### defdroite ###
%% syntaxe : A B /d defdroite
/defdroite {
1 dict begin
   /t@mp@r@ire exch def
   [ 5 1 roll ] cvx t@mp@r@ire exch 
end def
} def

%%%%% ### paral ###
%% syntaxe : D A paral --> droite parallele a D passant par A
/paral {
4 dict begin
   /yA exch def
   /xA exch def
   vecteur
   /u2 exch def
   /u1 exch def
   xA yA
   2 copy
   u1 u2 translatepoint
end
} def

%%%%% ### interdroite ###
/interdroite {
                %% A B C D
   /dr@ite2 4 array def
   dr@ite2 3 3 -1 roll put
   dr@ite2 2 3 -1 roll put
   dr@ite2 1 3 -1 roll put
   dr@ite2 0 3 -1 roll put
   /dr@ite1 4 array def
   dr@ite1 3 3 -1 roll put
   dr@ite1 2 3 -1 roll put
   dr@ite1 1 3 -1 roll put
   dr@ite1 0 3 -1 roll put

%%%    %% trace pour deboguage
%%%    dr@ite1 aload pop droite
%%%    dr@ite2 aload pop droite

%%% Dans tous les cas, on suppose que l'intersection existe
%%% 
%%% * la 1ere droite est verticale. les equations reduites sont
%%%       x = a1      et       y = a2 x + b2
%%% Le point d'intersection est :
%%%       {{x = a1, y = b2 + a1 a2}}
%%% 
%%% * la 2eme droite est verticale. les equations reduites sont
%%%       x = a1 x+ b1     et       x = a2
%%% Le point d'intersection est :
%%%       {{x = a2, y = b1 + a1 a2}}
%%% 
%%% * aucune n'est verticale. Les equations reduites sont
%%%       y = a1 x + b1      et       y = a2 x + b2
%%% Le point d'intersection est :
%%%                 { {     b2 - b1      a1 b2 - a2 b1 } }
%%%                 { { x = -------, y = ------------- } }
%%%                 { {     a1 - a2         a1 - a2    } }

%%% remarque : pour le moment, je n'arrive pas a rendre mes variables
%%% locales : elle restent globales. Pour que cela ne soit pas trop
%%% genant, je les note respectivement @1, @@1, @2 et @@2 au lieu de a1,
%%% b1, a2 et b2.

   dr@ite1 aload pop verticale?
      {
         /@1 {dr@ite1 aload pop pop pop pop} def
         /@2 {dr@ite2 aload pop coeffdir} def
         /@@2 {dr@ite2 aload pop ordorig} def
         @1 
         @1 @2 mul @@2 add
      }
      {
      dr@ite2 aload pop verticale?
         {
            /@1 {dr@ite1 aload pop coeffdir} def
            /@@1 {dr@ite1 aload pop ordorig} def
            /@2 {dr@ite2 aload pop pop pop pop} def
            @2
            @1 @2 mul @@1 add
         }
         {
            /@1 {dr@ite1 aload pop coeffdir} def
            /@@1 {dr@ite1 aload pop ordorig} def
            /@2 {dr@ite2 aload pop coeffdir} def
            /@@2 {dr@ite2 aload pop ordorig} def
            @@2 @@1 sub @1 @2 sub div
            @1 @@2 mul @2 @@1 mul sub
            @1 @2 sub div
         }
      ifelse
      }
   ifelse
} def

%%%%% ### perp ###
%% syntaxe : D A perp --> droite perpendiculaire a D passant par A
/perp {
4 dict begin
   /yA exch def
   /xA exch def
   vecteur orthovecteur
   /u2 exch def
   /u1 exch def
   xA yA
   2 copy
   u1 u2 translatepoint
end
} def

%%%%% ### mediatrice ###
%% synaxe : A B mediatrice --> droite
/mediatrice {
   4 copy 
   milieu
   perp
} def

%%%%% ### bissectrice ###
%% syntaxe : A B C bissectrice --> B E ou E est un point de la bissectrice
/bissectrice {
10 dict begin
   /yC exch def
   /xC exch def
   /yB exch def
   /xB exch def
   /yA exch def
   /xA exch def
   /A {xA yA} def
   /B {xB yB} def
   /C {xC yC} def
   /alpha {A B C tripointangle} def
   B
   A B alpha rotatepoint
   A milieu
end
} def

%%%%% ### angledroit  ###
 /widthangledroit 5 def

%% syntaxe : A B C angledroit --> dessine un angle droit en B
/angledroit {
10 dict begin
   dup xcheck {
      /widthangledroit exch def
   } if
   /C defpoint
   /B defpoint
   /A defpoint
   B C vecteur normalize widthangledroit 20 div mulv /u defpoint
   B A vecteur normalize widthangledroit 20 div mulv /v defpoint
   [B u addv dupp v addv B v addv] ligne
end
} def

%%%%% ### translatedroite ###
%% syntaxe : A B u translatedroite --> C D images resp de A et B par la translation de vecteur u
/translatedroite {         %% A B u
   2 copy          %% A B u u
   6 1 roll       
   6 1 roll        %% A u B u 
   addv      %% A u D
   6 1 roll        
   6 1 roll        %% D A u 
   addv
   4 1 roll
   4 1 roll
} def

%%%%% ### rotatedroite ###
%% syntaxe : A B O r rotatedroite --> C D images resp de A et B par la
%% rotation de centre O et d'angle r (en degre)
/rotatedroite {
   5 copy rotatepoint   %% A B O r D
   6 -1 roll pop        %% A xB O r D
   6 -1 roll pop        %% A O r D
   7 1 roll
   7 1 roll rotatepoint %% D C
   4 1 roll 4 1 roll 
} def

/rotatevecteur {
   rotatedroite
} def

/rotatesegment {
   rotatedroite
} def

%%%%% ### axesymdroite ###
%% syntaxe : d D axesymdroite --> droite d', symetrique de la droite d par rapport
%% a la droite D
/axesymdroite {
2 dict begin
   /D defdroite
   /B defpoint
   D axesympoint
   B D axesympoint
end   
} def

%%%%% ### fin insertion ###

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%                  polygones                         %%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%%%%% ### poltransformfile ###
%% syntaxe : pol u translatepol --> pol'
/translatepol {
2 dict begin   
   /uy exch def
   /ux exch def
   {ux uy translatepoint} papply
end
} def

%% syntaxe : pol u rotatepol --> pol'
/rotatepol {
2 dict begin   
   /alpha exch def
   /I defpoint
   {I alpha rotatepoint} papply
end
} def

%% syntaxe : pol I alpha hompol --> pol'
/hompol {
2 dict begin   
   /alpha exch def
   /I defpoint
   {I alpha hompoint} papply
end
} def

%% syntaxe : pol I sympol --> pol'
/sympol {
1 dict begin   
   /I defpoint
   {I sympoint} papply
end
} def

%% syntaxe : pol D axesympol --> pol'
/axesympol {
1 dict begin   
   /D defdroite
   {D axesympoint} papply
end
} def

%%%%% ### fin insertion ###

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%                  les tests                         %%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%%%%% ### isbool ###
%% syntaxe : any isbool --> booleen
/isbool {
   type (booleantype) cvn eq
} def

%%%%% ### isarray ###
%% syntaxe : any isarray --> booleen
/isarray {
   type (arraytype) cvn eq
} def

%%%%% ### isstring ###
%% syntaxe : any isstring --> booleen
/isstring {
   type (stringtype) cvn eq
} def

%%%%% ### isinteger ###
%% syntaxe : any isinteger --> booleen
/isinteger {
   type (integertype) cvn eq
} def

%%%%% ### isnum ###
%% syntaxe : any isnum --> booleen
/isnum {
   dup isreal 
   exch isinteger or
} def

%%%%% ### isreal ###
%% syntaxe : any isreal --> booleen
/isreal {
   type (realtype) cvn eq
} def

%%%%% ### eq ###
%% syntaxe : A B eqp3d --> booleen = true si les points A et B sont identiques
/eqp3d {
               %% x1 y1 z1 x2 y2 z2
   4 -1 roll   %% x1 y1 x2 y2 z2 z1 
   eq {        %% x1 y1 x2 y2 
      eqp
   } {
      pop pop pop pop false
   } ifelse
} def

%% syntaxe : A B eqp --> booleen = true si les points A et B sont identiques
/eqp {
   3 -1 roll
   eq 
      {
         eq 
            {true} 
            {false}
         ifelse
      }
      {pop pop false}
   ifelse
} def

%% syntaxe : z z' eqc --> true si z = z', false sinon
/eqc {
   eqp
} def

%%%%% ### eqstring ###
/eqstring {
3 dict begin
   /str2 exch def
   /str1 exch def
   str1 length str2 length eq {
      /i 0 def
      true
      str1 length {
         str1 i get str2 i get eq and
         /i i 1 add store
      } repeat
   } {
      false
   } ifelse
end
} def

%%%%% ### fin insertion ###

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%                conversions de types                %%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%%%%% ### astr2str ###
%% syntaxe : array str astr2str --> str
%% convertit le contenu de array en chaines de caracteres puis les
%% concatene avec str, en inserant un caractere "space" apres chaque
%% element du tableau array
/astr2str {
5 dict begin
   /str exch def
   /table exch def
   /n table length def
   n 0 eq {
      str
   } {
      table 0 n 1 sub getinterval
      table n 1 sub get (                               ) cvs
      ( ) append
      str append
      astr2str
   } ifelse
end
} def

%%%%% ### numstr2array ###
%% syntaxe : str str2num --> num
/str2num {
5 dict begin
   /str exch def
   /n str length def
   /signnum 1 def
   /frct false def
   /k 0 def
   0 1 n 1 sub {
      /i exch def
      str i get
      dup 46 eq {
         %% il y a un point
         /frct true def
         pop
         i 0 eq {
            0
         } if
      } {
         dup 45 eq {
            /signnum -1 def
            pop
         } {
            frct not {
               i 1 ge signnum 0 ge and i 2 ge or {
                  exch 10 mul 48 sub add
               } {
                  48 sub
               } ifelse
            } {
               48 sub
               /k k 1 add store
               10 k exp div add
            } ifelse
         } ifelse
      } ifelse
   } for
   signnum mul
end
} def

/str2num {cvx exec} def

%% syntaxe : str numstr2array -> array
%% ou str est une chaine de nombres reels separes par des espaces
%% et array est constitue des elements numeriques de string.
%% exemple :
%% (0 -12 .234 54) --> [0 -12 0.234 54]
/numstr2array {
6 dict begin
   /str exch def
   /n str length def
   /separateurs [] def
   [
      0 1 n 1 sub {
         /i exch def
         str i get
         32 eq {
            /separateurs [separateurs aload pop i] def
         } if
      } for
      /j 0 def
      /oldsep 0 def
      0 1 separateurs length 1 sub {
         /i exch def
         str j separateurs i get oldsep sub getinterval str2num
         /j separateurs i get 1 add def
         /oldsep separateurs i get 1 add def
      } for
      str j n oldsep sub getinterval str2num
   ]
end
} def

%% syntaxe : array numstr2array -> array
/arraynumstr2arrayarray {
   {numstr2array} apply
} def

%%%%% ### fin insertion ###

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%                macros de projection                %%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%%%%% ### projtext ###
%% syntaxe : str x0 y0 z0 [normal_vect] ultextp3d --> -
%% syntaxe : str x0 y0 z0 [normal_vect] bool ultextp3d --> -
%% syntaxe : str x0 y0 plantype ultextp3d --> -
%% syntaxe : str x0 y0 plantype bool ultextp3d --> -
%% syntaxe : str1 solid i str2 ultextp3d --> -
%% syntaxe : str1 solid i str2 bool ultextp3d --> -
%% syntaxe : str1 solid i alpha str2 bool ultextp3d --> -
 /initpr@jtext {
5 dict begin
   dup isbool {
      /mybool exch def
   } {
      /mybool true def
   } ifelse
   dup isplan {
      /type_plan_proj true def
      /lepl@n exch def
      lepl@n plangetbase aload pop
      /@V defpoint3d
      /@U defpoint3d
      lepl@n plangetorigine
      /z0 exch def
      /y0 exch def
      /x0 exch def
      /table [@U @U @V vectprod3d] def
   } {
      dup isarray {
         %% c est un planprojpath
         /type_plan_proj true def
         /table exch def
         /z0 exch def
         /y0 exch def
         /x0 exch def
         0 0
      } {
         %% c est un solidprojpath
         /type_plan_proj false def
         %% y a-t-il un str2
         dup isstring {
            /str2 exch def
         } {
            /str2 {} def
         } ifelse
         %% y a-t-il un alpha
         2 copy pop issolid {
            /alpha 0 def
         } {
            /alpha exch def
         } ifelse
         /i exch def
         /solid exch def
         0 0
      } ifelse
   } ifelse
} def
 /closepr@jtext {
   type_plan_proj {
      x0 y0 z0 table mybool projpath
   } {
      solid i alpha str2 mybool projpath
   } ifelse
   Fill
   Stroke
end
} def

%% syntaxe : str x0 y0 z0 [normal_vect] ultextp3d --> -
%% syntaxe : str x0 y0 z0 [normal_vect] bool ultextp3d --> -
%% syntaxe : str1 solid i str2 ultextp3d --> -
%% syntaxe : str1 solid i str2 bool ultextp3d --> -
%% syntaxe : str1 solid i alpha str2 bool ultextp3d --> -
/ultextp3d {initpr@jtext ultext_ closepr@jtext} def
/cltextp3d {initpr@jtext cltext_ closepr@jtext} def
/bltextp3d {initpr@jtext bltext_ closepr@jtext} def
/dltextp3d {initpr@jtext dltext_ closepr@jtext} def
/ubtextp3d {initpr@jtext ubtext_ closepr@jtext} def
/cbtextp3d {initpr@jtext cbtext_ closepr@jtext} def
/bbtextp3d {initpr@jtext bbtext_ closepr@jtext} def
/dbtextp3d {initpr@jtext dbtext_ closepr@jtext} def
/uctextp3d {initpr@jtext uctext_ closepr@jtext} def
/cctextp3d {initpr@jtext cctext_ closepr@jtext} def
/bctextp3d {initpr@jtext bctext_ closepr@jtext} def
/dctextp3d {initpr@jtext dctext_ closepr@jtext} def
/urtextp3d {initpr@jtext urtext_ closepr@jtext} def
/crtextp3d {initpr@jtext crtext_ closepr@jtext} def
/brtextp3d {initpr@jtext brtext_ closepr@jtext} def
/drtextp3d {initpr@jtext drtext_ closepr@jtext} def

%%%%% ### currentppathtransform ###
%% syntaxe : {f} currentppathtransform --> applique la transformation f
%% au chemin courant
/currentppathtransform {
6 dict begin
   /warp exch def
   %% pour remplacer 'move'
   /warpmove{
      2 index {
        newpath
      } if
      warp moveto
      pop false
   } def

   %% pour remplacer 'lineto'
   /warpline {
      warp lineto
   } bind def

   %% pour remplacer 'curveto'
   /warpcurve {
      6 2 roll warp
      6 2  roll warp
      6 2 roll warp
      curveto
   }  bind def

   true
   { warpmove } {  warpline } { warpcurve } { closepath } pathforall
   pop
end
} def

%% syntaxe : {f} currentpathtransform --> applique la transformation f
%% au chemin courant
/currentpathtransform {
7 dict begin
   /transform exch def
   /warp {ptojpoint transform} def
   %% pour remplacer 'move'
   /warpmove{
      2 index {
        newpath
      } if
      warp smoveto
      pop false
   } def

   %% pour remplacer 'lineto'
   /warpline {
      warp slineto
   } bind def

   %% pour remplacer 'curveto'
   /warpcurve {
      6 2 roll warp
      6 2  roll warp
      6 2 roll warp
      scurveto
   }  bind def

   true
   { warpmove } {  warpline } { warpcurve } { closepath } pathforall
   pop
end
} def

%%%%% ### normalvect_to_orthobase ###
%% syntaxe : [normal_vect] normalvect_to_orthobase
%%    --> imI imJ imK
/normalvect_to_orthobase {
4 dict begin
   dup length 3 eq {
      aload pop normalize3d /normal_vect defpoint3d
      normal_vect -1 0 0 eqp3d {
         /imageI {0 -1 0} def
         /imageK {-1 0 0} def
         /imageJ {0 0 1} def 
      } {
         %% on calcule l image de la base (I,J,K)
         /imageJ {normal_vect 1 0 0 vectprod3d normalize3d} def
         /imageK {normal_vect} def
         /imageI {imageJ imageK vectprod3d} def
         1 0 0 imageK angle3d 0 eq {
            0 1 0 normal_vect vectprod3d /imageI defpoint3d
            /imageJ {0 1 0} def
            normal_vect /imageK defpoint3d
         } if
      } ifelse
   } {
      dup length 6 eq {
         aload pop
         normalize3d /imageK defpoint3d
         normalize3d /imageI defpoint3d
         imageK imageI vectprod3d /imageJ defpoint3d
      } {
         dup length 7 eq {
            aload pop 
            /alpha exch 2 div def
            normalize3d /imageK defpoint3d
            normalize3d /imageI defpoint3d
            imageK imageI vectprod3d /imageJ defpoint3d
            %% et ensuite, on fait tourner la base autour de imageK
            imageI alpha cos mulv3d
            imageJ alpha sin mulv3d
            addv3d
   
            imageI alpha sin neg mulv3d
            imageJ alpha cos mulv3d
            addv3d
   
            /imageJ defpoint3d
            /imageI defpoint3d
         } {
            %% length = 4
            aload pop
            /alpha exch def
            normalize3d /normal_vect defpoint3d
   
            normal_vect -1 0 0 eqp3d {
               /imageI {0 -1 0} def
               /imageK {-1 0 0} def
               /imageJ {0 0 1} def 
            } {
               %% on calcule l image de la base (I,J,K)
               /imageJ {normal_vect 1 0 0 vectprod3d normalize3d} def
               /imageK {normal_vect} def
               /imageI {imageJ imageK vectprod3d} def
               1 0 0 imageK angle3d 0 eq {
                  0 1 0 normal_vect vectprod3d /imageI defpoint3d
                  /imageJ {0 1 0} def
                  normal_vect /imageK defpoint3d
               } if
            } ifelse
         } ifelse

         %% et ensuite, on fait tourner la base autour de imageK
         imageI alpha cos mulv3d
         imageJ alpha sin mulv3d
         addv3d

         imageI alpha sin neg mulv3d
         imageJ alpha cos mulv3d
         addv3d

         /imageJ defpoint3d
         /imageI defpoint3d
      } ifelse
   } ifelse
   imageI
   imageJ
   imageK
end
} def

%%%%% ### projpath ###
%% syntaxe : x y z [normal] projpath --> planprojpath
%% syntaxe : x y z [normal] bool projpath --> planprojpath
%% syntaxe : solid i projpath --> solidprojpath
%% syntaxe : solid i bool projpath --> solidprojpath
%% syntaxe : solid i str bool projpath --> solidprojpath
%% syntaxe : solid i alpha str bool projpath --> solidprojpath
/projpath {
2 dict begin
   dup isbool {
      /mybool exch def
   } {
      /mybool true def
   } ifelse
   dup isplan {
      3 dict begin
         /lepl@n exch def
         lepl@n plangetbase aload pop
         /@V defpoint3d
         /@U defpoint3d
         lepl@n plangetorigine
         [@U @U @V vectprod3d] mybool planprojpath
      end
   } {
      dup isarray {
         mybool planprojpath
      } {
         mybool solidprojpath
      } ifelse
   } ifelse
end
} def


%% %% syntaxe : x y z [normal] projpath --> planprojpath
%% %% syntaxe : x y z [normal] bool projpath --> planprojpath
%% %% syntaxe : solid i projpath --> solidprojpath
%% %% syntaxe : solid i bool projpath --> solidprojpath
%% %% syntaxe : solid i str bool projpath --> solidprojpath
%% %% syntaxe : solid i alpha str bool projpath --> solidprojpath
%% /projpath {
%% 2 dict begin
%%    dup isbool {
%%       /mybool exch def
%%    } {
%%       /mybool true def
%%    } ifelse
%%    dup isarray {
%%       mybool planprojpath
%%    } {
%%       mybool solidprojpath
%%    } ifelse
%% end
%% } def
%% 
%% syntaxe : solid i str bool solidprojpath --> -
%% ou
%% syntaxe : solid i alpha str bool solidprojpath --> -
%% projette le chemin courant sur la face i du solide, apres
%% eventuellement une rotation d angle alpha autour de la normale
%% bool : pour savoir si on tient compte de la visibilite
/solidprojpath {
5 dict begin
   /visibility exch def
   dup isstring {
      /option exch def
   } if
   2 copy pop
   issolid {
      /alpha 0 def
   } {
      /alpha exch def
   } ifelse
   /i exch def
   /solid exch def
   solid issolid not {
      (Error : mauvais type d argument dans solidprojpath) ==
   } if
   /n solid solidnombrefaces def
   i n 1 sub le {
      visibility not solid i solidfacevisible? or {
         currentdict /option known {
            option cvx exec
         } {
            solid i solidcentreface 
         } ifelse
         [
            solid 0 i solidgetsommetface 
            solid 1 i solidgetsommetface 
            vecteur3d normalize3d
            solid i solidnormaleface alpha 
         ] false planprojpath 
      } {
         newpath 0 0 smoveto
      } ifelse
   } {
      (Error : indice trop grand dans solidprojpath) ==
      quit
   } ifelse
end
} def

%% syntaxe : x y z [normal] bool planprojpath
/planprojpath {
6 dict begin
   /visibility exch def
   %% on calcule l image de la base (I,J,K)
   normalvect_to_orthobase
   /imageK defpoint3d
   /imageJ defpoint3d
   /imageI defpoint3d
   /z exch def
   /y exch def
   /x exch def

   visibility not x y z imageK planvisible? or {
      {ptojpoint 0
      imageI
      imageJ
      imageK
      transformpoint3d
      x y z addv3d
      3dto2d jtoppoint} currentppathtransform
   } {
      newpath
   } ifelse
end
} def

%%%%% ### projscene ###
%% syntaxe : plantype bool bprojscene ... eprojscene
/bprojscene {
10 dict begin
gsave
   dup isbool {
      /mybool exch def
   } {
      /mybool true def
   } ifelse
   /l@pl@n exch def
   /saveStroke {SolidesDict /Stroke get exec} def
   /Stroke {l@pl@n mybool projpath saveStroke} def
   /savefill {SolidesDict /Fill get exec} def 
   /Fill {l@pl@n mybool projpath savefill} def
   /masque {} def
   l@pl@n plangetrange aload pop 
   setyrange setxrange
   newpath
%%       xmin ymin l@pl@n pointplan smoveto
%%       xmin ymax l@pl@n pointplan slineto
%%       xmax ymax l@pl@n pointplan slineto
%%       xmax ymin l@pl@n pointplan slineto
%%       xmin ymin l@pl@n pointplan smoveto
%%  %   closepath
%% %gsave orange fill grestore
%%    clip
} def
/eprojscene {
grestore
end
} def

%%%%% ### fin insertion ###

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%          fonctions numeriques                      %%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%%%%% ### courbeparam ###
/setresolution {
   /resolution exch def
} def
/resolution 200 def

/courbe_dic 2 dict def
courbe_dic /X {} put
courbe_dic /Y {} put

%% syntaxe : tmin tmax C@urbeparam_
 /C@urbeparam_ {
6 dict begin
   /tmax@ exch def
   /tmin@ exch def
   /t tmin@ def
   /dt tmax@ tmin@ sub resolution 1 sub div def
   tmin@ courbe_dic /X get exec
   pstrickactionR
   tmin@ courbe_dic /Y get exec
   pstrickactionR
   smoveto
   resolution 1 sub
   {
      t courbe_dic /X get exec
      pstrickactionR
      t courbe_dic /Y get exec
      pstrickactionR
      slineto

      /t t dt add store                      %% on incremente
   }
   repeat
   tmax@ courbe_dic /X get exec
   pstrickactionR
   tmax@ courbe_dic /Y get exec
   pstrickactionR
   slineto
end
} def

%% syntaxe : tmin tmax {X} {Y} Courbeparam_
/Courbeparam_ {
   courbe_dic exch /Y exch put
   courbe_dic exch /X exch put
   C@urbeparam_
} def

%% syntaxe : {X} {Y} courbeparam_
/courbeparam_ {
   tmin tmax
   4 -1 roll
   4 -1 roll
   Courbeparam_
} def

%% syntaxe : tmin tmax {X} {Y} Courbeparam
/Courbeparam {
gsave
6 dict begin
   dup isstring
      {
         /option exch def
      }
   if
   courbe_dic exch /Y exch put
   courbe_dic exch /X exch put
   /tmax exch def
   /tmin exch def

   newpath
      tmin courbe_dic /X get exec
      pstrickactionR
      tmin courbe_dic /Y get exec
      pstrickactionR
      smoveto                        %% on commence le chemin
      tmin tmax C@urbeparam_
      starfill

   stockcurrentcpath
   newarrowpath
   currentdict /option known
      {
         /dt tmax tmin sub resolution 1 sub div def
         tmin dt add courbe_dic /X get exec
         tmin dt add courbe_dic /Y get exec
         tmin courbe_dic /X get exec
         tmin courbe_dic /Y get exec
         arrowpath0
         tmax dt sub courbe_dic /X get exec
         tmax dt sub courbe_dic /Y get exec
         tmax courbe_dic /X get exec
         tmax courbe_dic /Y get exec
         currentdict /dt undef
         arrowpath1
         option
         gere_arrowhead
      }
   if

   currentlinewidth 0 eq {} {Stroke} ifelse

end
grestore
} def

%% syntaxe : {X} {Y} courbeparam
/courbeparam {
   dup isstring
      {
         tmin tmax
         5 -1 roll
         5 -1 roll
         5 -1 roll
      }
      {
         tmin tmax
         4 -1 roll
         4 -1 roll
      }
   ifelse
   Courbeparam
} def

%% syntaxe : tmin tmax {X} {Y} Courbeparam*
/Courbeparam* {
1 dict begin
   /startest {true} def
   Courbeparam
end
} def

%% syntaxe : {X} {Y} courbeparam*
/courbeparam* {
1 dict begin
   /startest {true} def
   courbeparam
end
} def

%%%%% ### courbe ###
%% syntaxe : {f} courbe
/courbe {
   dup isstring   %% y a-t-il une option de fin de ligne ?
      {
         xmin xmax 
         {} 
         5 -1 roll
         5 -1 roll
      }
      {
         xmin xmax 
         {} 
         4 -1 roll
      }
   ifelse
   Courbeparam
} def

%% syntaxe : mini maxi {f} Courbe
/Courbe {
   dup isstring {
      {}
      3 -1 roll
      3 -1 roll
   } {
      {}
      2 -1 roll
   } ifelse
   Courbeparam
} def

%% syntaxe : {f} courbe_
/courbe_ {
   xmin xmax 
   {} 
   4 -1 roll
   Courbeparam_
} def

%% syntaxe : mini maxi {f} Courbe_
/Courbe_ {
   {}
   2 -1 roll
   Courbeparam_
} def

%% syntaxe : mini maxi {f} Courbe*
/Courbe* {
1 dict begin
   /startest {true} def
   Courbe
end
} def

%% syntaxe : {f} courbe*
/courbe* {
1 dict begin
   /startest {true} def
   courbe
end
} def

%%%%% ### courbeR2 ###
%% syntaxe : tmin tmax C@urbeR2_
 /C@urbeR2_ {
6 dict begin
   /tmax@ exch def
   /tmin@ exch def
   /t tmin@ def
   /dt tmax@ tmin@ sub resolution 1 sub div def
   tmin@ courbe_dic /X get exec
   pstrickactionR2
   smoveto
   /t t dt add store
   resolution 2 sub
   {
      t courbe_dic /X get exec
      pstrickactionR2
      slineto
      /t t dt add store                      %% on incremente
   }
   repeat
   tmax@ courbe_dic /X get exec
   pstrickactionR2
   slineto
end
} def

%% syntaxe : tmin tmax {X} CourbeR2_
/CourbeR2_ {
   courbe_dic exch /X exch put
   C@urbeR2_
} def

%% syntaxe : {X} courbeR2_
/courbeR2_ {
   tmin tmax
   3 -1 roll
   3 -1 roll
   CourbeR2_
} def

%% syntaxe : tmin tmax {X} CourbeR2
/CourbeR2+ {
2 dict begin
   /slineto {} def
   /smoveto {} def
   CourbeR2
end
} bind def

/CourbeR2 {
gsave
6 dict begin
   dup isstring
      {
         /option exch def
      }
   if
   courbe_dic exch /X exch put
   /tmax exch def
   /tmin exch def

   newpath
      tmin tmax C@urbeR2_
      starfill
   currentlinewidth 0 eq {} {Stroke} ifelse

end
grestore
} def

%% syntaxe : {X} courbeR2
/courbeR2 {
   tmin tmax
   3 -1 roll
   CourbeR2
} def

%% syntaxe : tmin tmax {X} CourbeR2*
/CourbeR2* {
1 dict begin
   /startest {true} def
   CourbeR2
end
} def

%% syntaxe : {X} {Y} courbeR2*
/courbeR2* {
1 dict begin
   /startest {true} def
   courbeR2
end
} def

%%%%% ### courbeR3 ###
%% syntaxe : t1 t2 {f} (option) CourbeR3
/CourbeR3 {
2 dict begin
   dup isstring {
      /option exch def
   } if
   /lafonction exch def
   {lafonction 3dto2d}
   currentdict /option known
      {option}
   if
  CourbeR2
end
} def

%% syntaxe : {f} (option) CourbeR3
/courbeR3 {
   tmin tmax 3 -1 roll CourbeR3
} def

%%%%% ### cercle ###
%% syntaxe : x0 y0 r cercle
/cercle {
3 dict begin
   /r@y@n exch def
   /y@ exch def
   /x@ exch def
   0 360 {cos r@y@n mul x@ add} {sin r@y@n mul y@ add} Courbeparam
end
} def

%% syntaxe : x0 y0 r cercle_
/cercle_ {
3 dict begin
   /r@y@n exch def
   /y@ exch def
   /x@ exch def
   x@ r@y@n add y@ smoveto
   0 360 {cos r@y@n mul x@ add} {sin r@y@n mul y@ add} Courbeparam_
end
} def

%% syntaxe : x0 y0 r cercle-_
/cercle-_ {
3 dict begin
   /r@y@n exch def
   /y@ exch def
   /x@ exch def
   x@ r@y@n add y@ smoveto
   360 0 {cos r@y@n mul x@ add} {sin r@y@n mul y@ add} Courbeparam_
end
} def

%% syntaxe : x0 y0 r cercle*
/cercle* {
1 dict begin
   /startest true def
   cercle
end
} def

%% syntaxe : alpha beta x0 y0 r Cercle
/Cercle {
4 dict begin
   dup isstring
      {/option exch def}
   if
   /r@y@n exch def
   /y@ exch def
   /x@ exch def
   {cos r@y@n mul x@ add} {sin r@y@n mul y@ add} 
   currentdict /option known
      {option}
   if
   Courbeparam
end
} def

%% syntaxe : alpha beta x0 y0 r Cercle_
/Cercle_ {
3 dict begin
   /r@y@n exch def
   /y@ exch def
   /x@ exch def
   {cos r@y@n mul x@ add} {sin r@y@n mul y@ add} Courbeparam_
end
} def

%% syntaxe : alpha beta x0 y0 r Cercle
/Cercle* {
1 dict begin
   /startest {true} def
   Cercle
end
} def

%%%%% ### fin insertion ###

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%      fonctions et constantes mathematiques         %%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%%%%% ### math ###
%%%%%%%%%%% constantes mathematiques %%%%%%%%%%%%%%

/pi 3.14159 def
/e 2.71828 def

%%%%%%%%%%% fonctions mathematiques %%%%%%%%%%%%%%%

/rd {180 pi div mul} def        %% transforme des rd en degres
/deg {pi mul 180 div} def       %% transforme des degres en rd
/log {ln 10 ln div} def
/Exp {e exch exp} def
/Cos {rd cos} def
/Sin {rd sin} def
/tan {dup sin exch cos div} def
/cotan {dup cos exch sin div} def
/Tan {dup Sin exch Cos div} def
/Cotan {dup Cos exch Sin div} def
/coTan {Cotan} def
/arctan {
dup 0 ge
   {1 atan}
   {neg 1 atan neg}
ifelse
} def
/Arctan {arctan deg} def
/arccos {
   dup
   dup mul neg 1 add sqrt
   exch
   atan
} def
/Arccos {arccos deg} def
/arcsin {
   dup 1 eq {
      90
   } {
      dup
      dup mul neg 1 add sqrt
      atan
      dup 90 lt
         {}
         {360 sub}
      ifelse
   } ifelse
} def
/Arcsin {arcsin deg} def
/cosh {dup Exp exch neg Exp add 2 div} def
/sinh {dup Exp exch neg Exp sub 2 div} def
/tanh {dup sinh exch cosh div} def
/cotanh {dup cosh exch sinh div} def
/argcosh {dup dup mul 1 sub sqrt add ln} def
/argsinh {dup dup mul 1 add sqrt add ln} def
/argtanh {
   setxvar
   x 1 add
   1 x sub
   div
   ln
   2 div
} def
/factorielle {
      dup 0 eq
         {pop 1}
         {dup 1 sub factorielle mul}
      ifelse
} def
/Gauss {
3 dict begin
   /sigma exch def
   /m exch def
   /x exch def
   x m sub dup mul sigma dup mul 2 mul div neg Exp
   2 pi mul sigma dup mul mul sqrt div
end
} def
%% syntaxe : a n modulo
/modulo {
2 dict begin
   /n exch def
   /a exch def
   {
      a 0 lt {
         /a a n add store
      } {
         exit
      } ifelse
   } loop
   a n mod
end
} def

%%%%% ### max ###
/max {
   2 copy
   lt {exch} if
   pop
} def

%%%%% ### min ###
/min {
2 dict begin
   dup isarray {
      duparray /table exch def pop
      table 0 get
      1 1 table length 1 sub {
         /i exch def
         table i get
         min
      } for
   } {
      2 copy
      gt {exch} if
      pop
   } ifelse
end
} def

%%%%% ### setcolor ###
%% syntaxe : tableau setcolor
/setcolor {
   dup length 4 eq
      {aload pop setcmykcolor}
      {aload pop setrgbcolor}
   ifelse
} def

%%%%% ### in ###
%% cherche si un elt donne appartient au tableau donne
%% rque : utilise 3 variables locales
%% syntaxe : elt array in --> index boolean
/in {
3 dict begin
   /liste exch def
   /elt exch def
   /i 0 def
   false                        %% la reponse a priori
   liste length {
      liste i get elt eq {
         pop                    %% en enleve la reponse
         i true                 %% pour mettre la bonne
         exit
      } if
      /i i 1 add store
   } repeat
end
} def

%% cherche si un elt donne appartient au tableau donne
%% syntaxe : elt array in --> boolean
/In {
3 dict begin
   /liste exch def
   /elt exch def
   /i 0 def
   false                        %% la reponse a priori
   liste length {
      liste i get elt eq {
         pop                    %% en enleve la reponse
         true                 %% pour mettre la bonne
         exit
      } if
      /i i 1 add store
   } repeat
end
} def

%%%%% ### starfill ###
%% la procedure pour les objets "star"
%% si c est "star" on fait le fillstyle, sinon non
/starfill {
   startest {
      gsave
         clip
         fillstyle
      grestore
      /startest false def
   } if
} def

%%%%% ### addv ###
%% syntaxe : u v addv --> u+v
/addv {         %% xA yA xB yB
   3 1 roll     %% xA yB yA xB 
   4 1 roll     %% xB xA yB yA 
   add 3 1 roll %% yB+yA xB xA 
   add exch
} def

%%%%% ### continu ### 
/continu {
   [] 0 setdash 
} def

%%%%% ### trigospherique ### 
%% passage spherique --> cartesiennes
%% les formules de passage ont été récupérées ici :
%%    http://fr.wikipedia.org/wiki/Coordonn%C3%A9es_polaires
%% syntaxe : r theta phi rtp2xyz -> x y z
/rtp2xyz {
6 dict begin
   /phi exch def
   /theta exch def
   /r exch def
   /x phi cos theta cos mul r mul def 
   /y phi cos theta sin mul r mul def
   /z phi sin r mul def
   x y z
end
} def

%% trace d'un arc sur une sphere de centre O
%% syntaxe : r theta1 phi1 r theta2 phi2 arcspherique
/arcspherique {
9 dict begin
   dup isstring {
      /option exch def
   } if
   /phi2 exch def
   /theta2 exch def
   pop
   /phi1 exch def
   /theta1 exch def
   /r exch def
   /n 12 def

   1 theta1 phi1 rtp2xyz /u defpoint3d
   1 theta2 phi2 rtp2xyz /v defpoint3d
   u v vectprod3d u vectprod3d dupp3d norme3d 1 exch div mulv3d /w defpoint3d

   /sinalpha u v vectprod3d norme3d def
   /cosalpha u v scalprod3d def
   /alpha sinalpha cosalpha atan def
   /n 12 def
   /pas alpha n div def

   gsave
      /t pas neg def
      [
         n 1 add {
            /t  t pas add store
            u t cos r mul mulv3d
            w t sin r mul mulv3d
            addv3d
         } repeat
      ] 
      currentdict /option known {
         option
      } if
      ligne3d
   grestore
end
} def

%% trace d'un arc sur une sphere de centre O
%% syntaxe : r theta1 phi1 r theta2 phi2 arcspherique
/arcspherique_ {
8 dict begin
   /phi2 exch def
   /theta2 exch def
   pop
   /phi1 exch def
   /theta1 exch def
   /r exch def
   /n 12 def

   1 theta1 phi1 rtp2xyz /u defpoint3d
   1 theta2 phi2 rtp2xyz /v defpoint3d
   u v vectprod3d u vectprod3d dupp3d norme3d 1 exch div mulv3d /w defpoint3d

   /sinalpha u v vectprod3d norme3d def
   /cosalpha u v scalprod3d def
   /alpha sinalpha cosalpha atan def
   /n 12 def
   /pas alpha n div def

   /t pas neg def
   [
      n 1 add {
         /t  t pas add store
         u t cos r mul mulv3d
         w t sin r mul mulv3d
         addv3d
      } repeat
   ] ligne3d_
end
} def

%% trace d'une geodesique sur une sphere de centre O
%% syntaxe : r theta1 phi1 r theta2 phi2 geodesique_sphere
/geodesique_sphere {
13 dict begin
   /phi2 exch def
   /theta2 exch def
   pop
   /phi1 exch def
   /theta1 exch def
   /r exch def
   /n 360 def

   1 theta1 phi1 rtp2xyz /u defpoint3d
   1 theta2 phi2 rtp2xyz /v defpoint3d
   u v vectprod3d u vectprod3d dupp3d norme3d 1 exch div mulv3d /w defpoint3d

   /sinalpha u v vectprod3d norme3d def
   /cosalpha u v scalprod3d def
   /alpha sinalpha cosalpha atan def
   /pas 360 n div def

   gsave
      /t pas neg def
      [
         n 1 add {
            /t  t pas add store
            u t cos r mul mulv3d
            w t sin r mul mulv3d
            addv3d
         } repeat
      ] ligne3d
   grestore
end
} def


%% syntaxe : A B C trianglespherique --> trace le rtiangle ABC
%% (coordonnees spheriques)
/trianglespherique* {
1 dict begin
   /startest {true} def
   trianglespherique
end
} def

/trianglespherique {
10 dict begin
   /C defpoint3d
   /B defpoint3d
   /A defpoint3d
   gsave
   newpath
      A rtp2xyz 3dto2d smoveto
      A B arcspherique_
      B C arcspherique_
      C A arcspherique_
   closepath
   starfill
   currentlinewidth 0 eq {} {Stroke} ifelse
   grestore
end
} def

%%%%% ### fin insertion ###

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%         operations sur les tableaux                %%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%%%%% ### duparray ###
/duparray {
1 dict begin
   /table exch def
   table
   [ table aload pop ]
end
} def

%%%%% ### append ###
%% syntaxe : string1 string2 append --> concatene les 2 chaines ou fusionne 2 tableaux
/append {
3 dict begin
   dup isarray {
      /tab2 exch def
      /tab1 exch def
      [ tab1 aload pop tab2 aload pop ]
   } {
      /str2 exch def
      /str1 exch def
      /result str1 length str2 length add string def
      str1 result copy pop
      result str1 length str2 putinterval
      result
   } ifelse
end
} def

%%%%% ### rollparray ###
%% syntaxe : array n rollparray -> array
%% opere une rotation de n sur les couplets du tableau array
/rollparray {
4 dict begin
   /k exch def
   /table exch def
   /n table length def
   k 0 eq {
       table
   } {
       k 0 ge {
          [ table aload pop 2 {n 1 roll} repeat ]
           k 1 sub
       } {
          [ table aload pop 2 {n -1 roll} repeat ]
           k 1 add
       } ifelse
       rollparray
   } ifelse
end
} def

%%%%% ### bubblesort ###
%% syntaxe : array bubblesort --> array2 trie par ordre croissant
%% code de Bill Casselman
%% http://www.math.ubc.ca/people/faculty/cass/graphics/text/www/
/bubblesort {
4 dict begin
   /a exch def
   /n a length 1 sub def
   n 0 gt {
      % at this point only the n+1 items in the bottom of a remain to
      % the sorted largest item in that blocks is to be moved up into
      % position n
      n {
         0 1 n 1 sub {
            /i exch def
            a i get a i 1 add get gt {
               % if a[i] > a[i+1] swap a[i] and a[i+1]
               a i 1 add
               a i get
               a i a i 1 add get
               % set new a[i] = old a[i+1]
               put
               % set new a[i+1] = old a[i]
               put
            } if
         } for
         /n n 1 sub def
      } repeat
   } if
   a
end
} def

%% syntaxe : array1 doublebubblesort --> array2 array3, array3 est
%% trie par ordre croissant et array2 correspond a la position des
%% indices de depart, ie si array1 = [3 2 4 1], alors array2 = [3 1 0 2]
%% code de Bill Casselman, modifie par jpv, 15/08/2006
%% http://www.math.ubc.ca/people/faculty/cass/graphics/text/www/
/doublebubblesort {
5 dict begin
   /table exch def
   /n table length 1 sub def
   /indices [ 0 1 n {} for ] def
   n 0 gt {
      % at this point only the n+1 items in the bottom of a remain to
      % the sorted largest item in that blocks is to be moved up into
      % position n
      n {
         0 1 n 1 sub {
            /i exch def
            table i get table i 1 add get gt {
               % if a[i] > a[i+1] swap a[i] and a[i+1]
               table i 1 add
               table i get
               table i table i 1 add get
               % set new a[i] = old a[i+1]
               put
               % set new a[i+1] = old a[i]
               put

               indices i 1 add
               indices i get
               indices i indices i 1 add get
               % set new a[i] = old a[i+1]
               put
               % set new a[i+1] = old a[i]
               put
            } if
         } for
         /n n 1 sub def
      } repeat
   } if
   indices table
end
} def

%%%%% ### quicksort ###
%% src : http://www.math.ubc.ca/~cass/graphics/text/www/code/sort.inc
%% code de Bill Casselman, modifie par jpv, 18/10/2007

/qsortdict 8 dict def

qsortdict begin

% args: /comp a L R x
% effect: effects a partition into two pieces [L j] [i R]
%     leaves i j on stack

/partition { 8 dict begin
/x exch def
/j exch def
/i exch def
/a exch def
load /comp exch def
{
  {
    a i get x comp exec not {
      exit
    } if
    /i i 1 add def
  } loop
  {
    x a j get comp exec not {
      exit
    } if
    /j j 1 sub def
  } loop

  i j le {
    % swap a[i] a[j]
    a j a i get
    a i a j get
    put put
    indices j indices i get
    indices i indices j get
    put put
    /i i 1 add def
    /j j 1 sub def
  } if
  i j gt {
    exit
  } if
} loop
i j
end } def

% args: /comp a L R
% effect: sorts a[L .. R] according to comp

/subsort {
% /c a L R
[ 3 1 roll ] 3 copy
% /c a [L R] /c a [L R]
aload aload pop
% /c a [L R] /c a L R L R
add 2 idiv
% /c a [L R] /c a L R (L+R)/2
3 index exch get
% /c a [L R] /c a L R x
partition
% /c a [L R] i j
% if j > L subsort(a, L, j)
dup
% /c a [L R] i j j
3 index 0 get gt {
  % /c a [L R] i j
  5 copy
  % /c a [L R] i j /c a [L R] i j
  exch pop
  % /c a [L R] i j /c a [L R] j
  exch 0 get exch
  % ... /c a L j
  subsort
} if
% /c a [L R] i j
pop dup
% /c a [L R] i i
% if i < R subsort(a, i, R)
2 index 1 get lt {
  % /c a [L R] i
  exch 1 get
  % /c a i R
  subsort
}{
  4 { pop } repeat
} ifelse
} def

end

% args: /comp a
% effect: sorts the array a
% comp returns truth of x < y for entries in a

/quicksort { qsortdict begin
dup length 1 gt {
% /comp a
dup
% /comp a a
length 1 sub
% /comp a n-1
0 exch subsort
} {
pop pop
} ifelse
end } def

% ----------------------------------------

%% fin du code de Bill Casselman

%% syntaxe : array1 doublebubblesort --> array2 array3, array3 est
%% trie par ordre croissant et array2 correspond a la position des
%% indices de depart, ie si array1 = [3 2 4 1], alors array2 = [3 1 0 2]
%% code de Bill Casselman, modifie par jpv, 18/10/2007
%% http://www.math.ubc.ca/people/faculty/cass/graphics/text/www/
/doublequicksort {
qsortdict begin
   /comp exch
   /a exch def
   a dup length /n exch def
   /indices [0 1 n 1 sub {} for ] def
   dup length 1 gt {
      % /comp a
      dup
      % /comp a a
      length 1 sub
      % /comp a n-1
      0 exch subsort
   } {
      pop pop
   } ifelse
   indices a
end
} def

/comp {lt} def

%%%%% ### apply ###
%% syntaxe : [x1 ... xn] (f) apply --> [f(x1) ... f(xn)]
/apply {
3 dict begin
   dup isstring
      {/fonction exch cvx def}
      {/fonction exch def}
   ifelse
   /liste exch def
   /@i 0 def
   [
   liste length {
      liste @i get fonction
      /@i @i 1 add store
   } repeat
   counttomark
   0 eq
      {pop}
      {]}
   ifelse
end
} def

%% syntaxe : [x1 ... xn] (f) papply
/papply {
3 dict begin
   dup isstring
      {/fonction exch cvx def}
      {/fonction exch def}
   ifelse
   /liste exch def
   /@i 0 def
   [
   liste length 2 idiv {
      liste @i get
      liste @i 1 add get
      fonction
      /@i @i 2 add store
   } repeat
   counttomark
   0 eq
      {pop}
      {]}
   ifelse
end
} def

%% syntaxe : [x1 ... xn] (f) capply 
/capply {
3 dict begin
   dup isstring
      {/fonction exch cvx def}
      {/fonction exch def}
   ifelse   
   /liste exch def
   /@i 0 def
   [
   liste length 3 idiv {
      liste @i get 
      liste @i 1 add get 
      liste @i 2 add get 
      fonction
      /@i @i 3 add store
   } repeat
   counttomark 
   0 eq
      {pop}
      {]}
   ifelse
end
} def

%%%%% ### reverse ###
%% syntaxe : array reverse --> inverse l ordre des items dans
%% le tableau
/reverse {
3 dict begin
   /le_tableau exch def
   /n le_tableau length def
   /i n 1 sub def
   [
      n {
         le_tableau i get
         /i i 1 sub store
      } repeat
   ]
end
} def

%% syntaxe : array_points reversep --> inverse l ordre des points dans
%% le tableau
/reversep {
3 dict begin
   /le_tableau exch def
   /n le_tableau length 2 idiv def
   /i n 1 sub def
   [
      n {
         le_tableau i getp
         /i i 1 sub store
      } repeat
   ]
end
} def

%%%%% ### get ###
%% syntaxe : array_points n getp --> le n-ieme point du tableau de
%% points array_points
/getp {
   2 copy
   2 mul get
   3 1 roll
   2 mul 1 add get
} def

%%%%% ### fin insertion ###

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%             matrices                               %%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%%%%% ### linear ###
%% syntaxe : M i j any --> depose any dans M en a_ij
/put_ij {
5 dict begin
   /a exch def
   /j exch def
   /i exch def
   /M exch def
   /L M i get_Li def
   L j a put
   M i L put_Li
end
} def

%% syntaxe : M i j get_ij --> le coeff c_ij
/get_ij {
   3 1 roll   %% j M i
   get_Li     %% j L_i
   exch get
} def

%% syntaxe : M i L put_Li --> remplace dans M la ligne Li par L
/put_Li {
   put
} def

%% syntaxe : M i get_Li --> la ligne Li de M
/get_Li {
   get
} def

%%%%% ### fin insertion ###

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%          geometrie 3d (calculs)                    %%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%%%%% ### sortp3d ### 
/sortp3d {
6 dict begin
   /M1 defpoint3d
   /M0 defpoint3d
   M1
   /z1 exch def
   /y1 exch def
   /x1 exch def
   M0
   /z0 exch def
   /y0 exch def
   /x0 exch def
   x0 x1 lt {
      M0 M1
   } {
      x0 x1 gt {
         M1 M0
      } {
         y0 y1 lt {
            M0 M1
         } {
            y0 y1 gt {
               M1 M0
            } {
               z0 z1 lt {
                  M0 M1
               } {
                  M1 M0
               } ifelse
            } ifelse
         } ifelse
      } ifelse
   } ifelse
end
} def

%%%%% ### dupp3d ### 
%% duplique le vecteur 3d
/dupp3d { %% x y z
        3 copy
} def
/dupv3d {dupp3d} def

%%%%% ### angle3d ###
%% syntaxe : vect1 vect2 angle3d
/angle3d {
4 dict begin
   normalize3d /vect2 defpoint3d
   normalize3d /vect1 defpoint3d
   /cosalpha vect1 vect2 scalprod3d def
   /sinalpha vect1 vect2 vectprod3d norme3d def
   sinalpha cosalpha atan
end
} def

%%%%% ### transformpoint3d ###
%% syntaxe : x y z a11 a21 a31 a12 a22 a32 a13 a23 a33
%%    transformpoint3d -> X Y Z
/transformpoint3d {
12 dict begin
   /a33 exch def
   /a23 exch def
   /a13 exch def
   /a32 exch def
   /a22 exch def
   /a12 exch def
   /a31 exch def
   /a21 exch def
   /a11 exch def
   /z   exch def
   /y   exch def
   /x   exch def
   a11 x mul a12 y mul add a13 z mul add
   a21 x mul a22 y mul add a23 z mul add
   a31 x mul a32 y mul add a33 z mul add
end
} def

%%%%% ### normalize3d ###
%% rend le vecteur 3d unitaire. Ne fait rien si u=0
/unitaire3d { %% x y z
2 dict begin
   /u defpoint3d
   /norme u norme3d def
   norme 0 eq {
      u
   } {
      u 1 norme div mulv3d
   } ifelse
end
} def
/normalize3d {unitaire3d} def

%%%%% ### geom3d ###
%% syntaxe : A k1 B k2 barycentre3d -> G, barycentre du systeme
%% [(A, k1) (B, k2)]
/barycentre3d {
4 dict begin
   /k2 exch def
   /B defpoint3d
   /k1 exch def
   /A defpoint3d
   A k1 mulv3d
   B k2 mulv3d
   addv3d
   1 k1 k2 add div mulv3d
end
} def

%% syntaxe : array isobarycentre3d --> G
/isobarycentre3d {
2 dict begin
   /table exch def
   /n table length 3 idiv def
   table 0 getp3d
   1 1 n 1 sub {
       table exch getp3d
       addv3d
   } for
   1 n div mulv3d
end
} def

%% syntaxe : M A alpha hompoint3d -> le point M' tel que AM' = alpha AM 
/hompoint3d {
3 dict begin
   /alpha exch def
   /A defpoint3d
   /M defpoint3d
   A M vecteur3d alpha mulv3d A addv3d
end
} def

%% syntaxe : M A sympoint3d -> le point M' tel que AM' = -AM
/sympoint3d {
2 dict begin
   /A defpoint3d
   /M defpoint3d
   A M vecteur3d -1 mulv3d A addv3d
end
} def

%% syntaxe : A u translatepoint3d --> B image de A par la translation de vecteur u
/translatepoint3d {
   addv3d
} def

/scaleOpoint3d {
6 dict begin
   /k3 exch def
   /k2 exch def
   /k1 exch def
   /z exch def
   /y exch def
   /x exch def
   k1 x mul
   k2 y mul
   k3 z mul
end
} def

% syntaxe : M alpha_x alpha_y alpha_z rotateOpoint3d --> M'
/rotateOpoint3d {
21 dict begin
   /RotZ exch def
   /RotY exch def
   /RotX exch def
   /Zpoint exch def
   /Ypoint exch def
   /Xpoint exch def
   /c1 {RotX cos} bind def
   /c2 {RotY cos} bind def
   /c3 {RotZ cos} bind def
   /s1 {RotX sin} bind def
   /s2 {RotY sin} bind def
   /s3 {RotZ sin} bind def
   /M11 {c2 c3 mul} bind def
   /M12 {c3 s1 mul s2 mul c1 s3 mul sub} bind def
   /M13 {c1 c3 mul s2 mul s1 s3 mul add} bind def
   /M21 {c2 s3 mul} bind def
   /M22 {s1 s2 mul s3 mul c1 c3 mul add} bind def
   /M23 {s3 s2 mul c1 mul c3 s1 mul sub} bind def
   /M31 {s2 neg} bind def
   /M32 {s1 c2 mul} bind def
   /M33 {c1 c2 mul} bind def
   M11 Xpoint mul M12 Ypoint mul add M13 Zpoint mul add
   M21 Xpoint mul M22 Ypoint mul add M23 Zpoint mul add
   M31 Xpoint mul M32 Ypoint mul add M33 Zpoint mul add
end
} def

%%%%% ### symplan3d ###
%% syntaxe : M eqplan/plantype symplan3d --> M'
%% ou M' symetrique de M par rapport au plan P defini par eqplan/plantype
/symplan3d {
13 dict begin
   dup isplan {
      plan2eq /args exch def
   } {
      /args exch def
   } ifelse
   /z exch def
   /y exch def
   /x exch def
   args aload pop
   /d1 exch def
   /c1 exch def
   /b1 exch def
   /a1 exch def
   /n_U a1 dup mul b1 dup mul add c1 dup mul add sqrt def
   /a a1 n_U div def
   /b b1 n_U div def
   /c c1 n_U div def
   /d d1 n_U div def
   /u a x mul b y mul add c z mul add d add def
   x 2 a mul u mul sub
   y 2 b mul u mul sub
   z 2 c mul u mul sub
end
} def

%%%%% ### vecteur3d ###
%% creation du vecteur AB a partir de A et B
/vecteur3d { %% xA yA zA xB yB zB
6 dict begin
   /zB exch def
   /yB exch def
   /xB exch def
   /zA exch def
   /yA exch def
   /xA exch def
   xB xA sub
   yB yA sub
   zB zA sub
end
}def

%%%%% ### vectprod3d ###
%% produit vectoriel de deux vecteurs 3d
/vectprod3d { %% x1 y1 z1 x2 y2 z2
6 dict begin
   /zp exch def
   /yp exch def
   /xp exch def
   /z exch def
   /y exch def
   /x exch def
   y zp mul z yp mul sub
   z xp mul x zp mul sub
   x yp mul y xp mul sub
end
} def

%%%%% ### scalprod3d ###
%% produit scalaire de deux vecteurs 3d
/scalprod3d { %% x1 y1 z1 x2 y2 z2
6 dict begin
   /zp exch def
   /yp exch def
   /xp exch def
   /z exch def
   /y exch def
   /x exch def
   x xp mul y yp mul add z zp mul add
end
} def

%%%%% ### papply3d ###
%% syntaxe : [A1 ... An] (f) papply3d --> [f(A1) ... f(An)]
/papply3d {
3 dict begin
   /fonction exch def
   /liste exch def
   /i 0 def
   [
   liste length 3 idiv {
      liste i get
      liste i 1 add get
      liste i 2 add get
      fonction
      /i i 3 add store
   } repeat
   counttomark
   0 eq
      {pop}
      {]}
   ifelse
end
} def

%%%%% ### defpoint3d ###
%% creation du point A a partir de xA yA yB et du nom /A
/defpoint3d { %% xA yA zA /nom
1 dict begin
   /memo exch def
   [ 4 1 roll ] cvx memo exch
end def
}def

%%%%% ### distance3d ###
/distance3d { %% A B
   vecteur3d norme3d
} def

%%%%% ### get3d ###
/getp3d { %% [tableau de points 3d] i --> donne le ieme point du tableau
   2 copy 2 copy
   3 mul get
   5 1 roll
   3 mul 1 add get
   3 1 roll
   3 mul 2 add get
} def

%%%%% ### norme3d ###
%% norme d un vecteur 3d
/norme3d { %% x y z
3 dict begin
   /z exch def
   /y exch def
   /x exch def
   x dup mul y dup mul add z dup mul add sqrt
end
} def

%%%%% ### mulv3d ###
%% (scalaire)*(vecteur 3d) Attention : dans l autre sens !
/mulv3d { %% x y z lambda
4 dict begin
   /lambda exch def
   /z exch def
   /y exch def
   /x exch def
   x lambda mul
   y lambda mul
   z lambda mul
end
} def

%%%%% ### addv3d ###
%% addition de deux vecteurs 3d
/addv3d { %% x1 y1 z1 x2 y2 z2
6 dict begin
   /zp exch def
   /yp exch def
   /xp exch def
   /z exch def
   /y exch def
   /x exch def
   x xp add
   y yp add
   z zp add
end
} def

%%%%% ### milieu3d ###
/milieu3d { %% A B --> I le milieu de [AB]
   addv3d 0.5 mulv3d
} def

%%%%% ### exch ###
/exchp {
   4 -1 roll
   4 -1 roll
} def
/exchc {
   6 -1 roll
   6 -1 roll
   6 -1 roll
} def
/exchd {
   4 {8 -1 roll} repeat
} def
/exchp3d {
   6 -1 roll
   6 -1 roll
   6 -1 roll
} def

%%%%% ### ABpoint3d ###
%% syntaxe : A B k ABpoint3d --> M
%% M tel que vect(AM) = k vect (AB)
/ABpoint3d {
3 dict begin
   /k exch def
   /B defpoint3d
   /A defpoint3d
   A B vecteur3d
   k mulv3d
   A addv3d 
end
} def

%%%%% ### angle3doriente ###
%% syntaxe : vect1 vect2 vect3 angle3d
%% vect3 est la normale au plan (vect1, vect2)
/angle3doriente {
4 dict begin
   normalize3d /vect3 defpoint3d
   normalize3d /vect2 defpoint3d
   normalize3d /vect1 defpoint3d
   /cosalpha vect1 vect2 scalprod3d def
   /sinalpha vect1 vect2 vectprod3d vect3 scalprod3d def
   sinalpha cosalpha atan
end
} def

%%%%% ### points3dalignes ###
%% syntaxe : A B C points3dalignes -> bool
/points3dalignes {
3 dict begin
   /C defpoint3d
   /B defpoint3d
   /A defpoint3d
   A B vecteur3d /u defpoint3d
   A C vecteur3d /v defpoint3d
   u v vectprod3d norme3d 1E-7 lt
end
} def

%% syntaxe : M A B point3dsursegment --> true si M in [AB], false sinon
/point3dsursegment {
3 dict begin
   /B defpoint3d
   /A defpoint3d
   /M defpoint3d
   M A B points3dalignes {
      M A vecteur3d
      M B vecteur3d
      scalprod3d 0 lt {
         true
      } {
         false
      } ifelse
   } {
      false
   } ifelse
end
} def

%%%%% ### fin insertion ###

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%          geometrie 3d (dessins)                    %%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%%%%% ### point3d ###
/point3d { %% A
   3dto2d point
} def

/points3d { %% tableau de points3d
   tab3dto2d points
} def

%%%%% ### ligne3d ###
%% [tableau de points3d] option --> trace la ligne brisee
/ligne3d { 
1 dict begin
   dup isstring
      {/option exch def}
   if
   tab3dto2d
   currentdict /option known
      {option}
   if
   ligne
end
} def

%% [tableau de points3d] option --> trace la ligne brisee
/ligne3d_ { 
1 dict begin
   dup isstring
      {/option exch def}
   if
   tab3dto2d
   currentdict /option known
      {option}
   if
   ligne_
end
} def

%%%%% ### tab3dto2d ###
%% transforme un tableau de points 3d en tableau de points 2d
/tab3dto2d {
2 dict begin
   /T exch def
   /n T length def
   [ T aload pop
   n 1 sub -1 n 3 idiv 2 mul
   { 1 dict begin
   /i exch def
   3dto2d i 2 roll
   end } for ]
end
} def

%%%%% ### polygone3d ###
/polygone3d { %% tableau de points3d
   tab3dto2d polygone
} def

/polygone3d* { %% tableau de points3d
   tab3dto2d polygone*
} def

%%%%% ### fin insertion ###

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%                 gestion du texte                   %%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%%%%% ### marks ###
/xmkstep 1 def          % les marques sur Ox
/xmarkstyle {dctext} def
/ymarkstyle {(-1 0) bltext} def
/setxmkstep {
   /xmkstep exch def
} def
/xmark {
   dup xtick
   /Courier findfont .8 fontsize mul scalefont setfont
   dup dup truncate eq {
      cvi dup chaine cvs exch 
   } {
      dup chaine cvs exch 
   } ifelse
   Oy xmarkstyle
} def
/xmarks {
2 dict begin
   /n xmax xmax xmin sub 1000 div sub xmkstep div truncate cvi 
      xmkstep mul def                   % mark max
   /i xmin xmkstep div truncate cvi 
      xmkstep mul def                   % la 1ere
   i xmin lt {/i i xmkstep add store} if
   {
      i 0 ne {i xmark} if
      /i i xmkstep abs add store
      i n gt {exit} if
   } loop 
end
} def

/ymkstep 1 def          % les marques sur Oy
/setymkstep {
   /ymkstep exch def
} def
/ymark {
   dup ytick
   /Courier findfont .8 fontsize mul scalefont setfont
   dup chaine cvs exch 
   Ox exch ymarkstyle
} def
/ymarks {
2 dict begin
   /n ymax ymax ymin sub 1000 div sub ymkstep div truncate cvi 
      ymkstep mul def                   % mark max
   /i ymin ymkstep div truncate cvi 
      ymkstep mul def                   % la 1ere
   {
      i 0 ne {i ymark} if
      /i i ymkstep abs add store
      i n gt {exit} if
   } loop 
end
} def

/setmkstep {
   setymkstep
   setxmkstep
} def
/marks {
   xmarks
   ymarks
} def

%%%%% ### setfontsize ###
/setfontsize {
   /fontsize exch def
} def

%%%%% ### setCourrier ###
/Courier findfont 
dup length dict begin
   {
   1 index /FID ne 
      {def}
      {pop pop} 
   ifelse
   } forall
   /Encoding ISOLatin1Encoding def
   currentdict
end

/Courier-ISOLatin1 exch definefont pop

/setCourier {
   /Courier-ISOLatin1 findfont 
   fontsize scalefont 
   setfont
} def

%%%%% ### pathtext ###
%% syntaxe : string x y initp@thtext
 /initp@thtext {
7 dict begin
   /y exch def
   /x exch def
   /str exch def
   str 0 0 show_dim
   /wy exch def
   /wx exch def
   /lly exch def
   /llx exch def
   pop pop pop
   newpath 
      x y  smoveto
} def
 /closep@thtext {
      str true charpath
end
} def

%% syntaxe : string x y cctext_
/cctext_ {
   initp@thtext
   llx wx add lly wy add -.5 mulv rmoveto
   closep@thtext
} def

/brtext_ {
   initp@thtext
   hadjust 0 rmoveto
   llx neg 0 rmoveto
   closep@thtext
} def

/bbtext_ {
   initp@thtext
   0 0 rmoveto
   0 0 rmoveto
   closep@thtext
} def

/bltext_ {
   initp@thtext
   hadjust neg 0 rmoveto
   wx neg 0 rmoveto
   closep@thtext
} def

/bctext_ {
   initp@thtext
   0 0 rmoveto
   wx llx add -.5 mul 0 rmoveto
   closep@thtext
} def

/ubtext_ {
   initp@thtext
   0 vadjust rmoveto
   0 lly neg rmoveto
   closep@thtext
} def

/urtext_ {
   initp@thtext
   hadjust vadjust rmoveto
   llx neg lly neg rmoveto
   closep@thtext
} def

/ultext_ {
   initp@thtext
   hadjust neg vadjust rmoveto
   wx neg lly neg rmoveto
   closep@thtext
} def

/uctext_ {
   initp@thtext
   0 vadjust rmoveto
   llx wx add -.5 mul lly neg rmoveto
   closep@thtext
} def

/drtext_ {
   initp@thtext
   hadjust vadjust neg rmoveto
   llx neg wy neg rmoveto
   closep@thtext
} def

/dbtext_ {
   initp@thtext
   0 vadjust neg rmoveto
   0 wy neg rmoveto
   closep@thtext
} def

/dltext_ {
   initp@thtext
   hadjust neg vadjust neg rmoveto
   wx neg wy neg rmoveto
   closep@thtext
} def

/dctext_ {
   initp@thtext
   0 vadjust neg rmoveto
   llx wx add -2 div wy neg rmoveto
   closep@thtext
} def

/crtext_ {
   initp@thtext
   hadjust 0 rmoveto
   llx neg lly wy add -2 div rmoveto
   closep@thtext
} def

/cbtext_ {
   initp@thtext
   0 0 rmoveto
   0 lly wy add -2 div rmoveto
   closep@thtext
} def

/cltext_ {
   initp@thtext
   hadjust neg 0 rmoveto
   wx neg lly wy add -2 div rmoveto
   closep@thtext
} def

/cctext_ {
   initp@thtext
   0 0 rmoveto
   llx wx add lly wy add -.5 mulv rmoveto
   closep@thtext
} def

%%%%% ### text3d ###
%%%% Version 3d des commandes jps TEXTE
 /pr@p@re3d {
2 dict begin
%   /vect_echelle [1 1] def
%   /angle_de_rot {0} def
%   dup xcheck
%      {/angle_de_rot exch def}
%   if
%   dup isarray
%      {/vect_echelle exch def}
%   if%   CamView vect_echelle {angle_de_rot}
   3dto2d
} def

/bbtext3d {
   pr@p@re3d
   bbtext
end
} def

/bbtexlabel3d {
   pr@p@re3d
   bbtexlabel
end
} def

/bctext3d {
   pr@p@re3d
   bctext
end
} def

/bctexlabel3d {
   pr@p@re3d
   bctexlabel
end
} def

/bltext3d {
   pr@p@re3d
   bltext
end
} def

/bltexlabel3d {
   pr@p@re3d
   bltexlabel
end
} def

/brtext3d {
   pr@p@re3d
   brtext
end
} def

/brtexlabel3d {
   pr@p@re3d
   brtexlabel
end
} def

/cbtext3d {
   pr@p@re3d
   cbtext
end
} def

/cbtexlabel3d {
   pr@p@re3d
   cbtexlabel
end
} def

/cctext3d {
   pr@p@re3d
   cctext
end
} def

/cctexlabel3d {
   pr@p@re3d
   cctexlabel
end
} def

/cltext3d {
   pr@p@re3d
   cltext
end
} def

/cltexlabel3d {
   pr@p@re3d
   cltexlabel
end
} def

/crtext3d {
   pr@p@re3d
   crtext
end
} def

/crtexlabel3d {
   pr@p@re3d
   crtexlabel
end
} def

/dbtext3d {
   pr@p@re3d
   dbtext
end
} def

/dbtexlabel3d {
   pr@p@re3d
   dbtexlabel
end
} def

/dctext3d {
   pr@p@re3d
   dctext
end
} def

/dctexlabel3d {
   pr@p@re3d
   dctexlabel
end
} def

/dltext3d {
   pr@p@re3d
   dltext
end
} def

/dltexlabel3d {
   pr@p@re3d
   dltexlabel
end
} def

/drtext3d {
   pr@p@re3d
   drtext
end
} def

/drtexlabel3d {
   pr@p@re3d
   drtexlabel
end
} def

/ubtext3d {
   pr@p@re3d
   ubtext
end
} def

/ubtexlabel3d {
   pr@p@re3d
   ubtexlabel
end
} def

/uctext3d {
   pr@p@re3d
   uctext
end
} def

/uctexlabel3d {
   pr@p@re3d
   uctexlabel
end
} def

/ultext3d {
   pr@p@re3d
   ultext
end
} def

/ultexlabel3d {
   pr@p@re3d
   ultexlabel
end
} def

/urtext3d {
   pr@p@re3d
   urtext
end
} def

/urtexlabel3d {
   pr@p@re3d
   urtexlabel
end
} def

%%%%% ### fin insertion ###

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%             bibliotheque sur les solides           %%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%%%%% ### solide ###
%% solid = [Sommets Faces Colors_Faces InOut_Table]
/solidgetsommets {
   0 get
} def
/solidgetpointstable {solidgetsommets} def

/solidgetfaces {
   1 get
} def

/solidgetface {
1 dict begin
   /i exch def
   solidgetfaces i get
end
} def

/solidgetfcolors {
   2 get
} def

%% syntaxe : solid i solidgetfcolor --> str
/solidgetfcolor {
1 dict begin
   /i exch def
   solidgetfcolors i get
end
} def

%% syntaxe : solid i str solidputfcolor --> -
/solidputfcolor {
2 dict begin
   /str exch def
   /i exch def
   solidgetfcolors i str put
end
} def

/solidgetinouttable {
   3 get
} def

/solidputsommets {
   0 exch put
} def
/solidputpointstable {solidputsommets} def

/solidputfaces {
   1 exch put
} def

%% syntaxe : solid solidfacesreverse -> -
/solidfacesreverse {
5 dict begin
   /solid exch def
   /n solid solidnombrefaces def
   0 1 n 1 sub {
      /i exch def
      /F solid i solidgetface reverse def
      /m F length def
      solid i [F aload pop m 0 roll ] solidputface
   } for
end
} def

/solidputfcolors {
   2 exch put
} def

/solidputinouttable {
   3 exch put
} def

%% syntaxe : any issolid --> booleen, vrai si any est de type solid
/issolid {
1 dict begin
   /candidat exch def
   candidat isarray {
      candidat length 4 eq {
         candidat 0 get isarray
         candidat 1 get isarray and
         candidat 2 get isarray and
         candidat 3 get isarray and {
            /IO candidat 3 get def
            IO length 4 eq 
            IO 0 get isnum and
            IO 1 get isnum and
            IO 2 get isnum and
            IO 3 get isnum and
         } {
            false
         } ifelse
      } {
         false
      } ifelse
   } {
      false
   } ifelse
end
} def

/dupsolid {
5 dict begin
   /solid exch def
   /S solid solidgetsommets def
   /F solid solidgetfaces def
   /FC solid solidgetfcolors def
   /IO solid solidgetinouttable def
   solid
   [
      S duparray exch pop
      F duparray exch pop
      FC duparray exch pop
      IO duparray exch pop
   ]
end
} def

%% syntaxe : solid array solidputinfaces --> -
/solidputinfaces {
4 dict begin
   /facesinternes exch def
   /solid exch def
   /n2 facesinternes length def
   /IO solid solidgetinouttable def
   /facesexternes solid solidgetoutfaces def
   /n1 facesexternes length def
   solid
      [facesexternes aload pop facesinternes aload pop]
      solidputfaces
   IO 0 0 put
   IO 1 n1 1 sub put
   IO 2 n1 put
   IO 3 n1 n2 add 1 sub put
end
} def

%% syntaxe : solid array solidputoutfaces --> -
/solidputoutfaces {
4 dict begin
   /facesexternes exch def
   /solid exch def
   /n1 facesexternes length def
   /IO solid solidgetinouttable def
   /facesinternes solid solidgetinfaces def
   /n2 facesinternes length def
   solid
      [facesexternes aload pop facesinternes aload pop]
      solidputfaces
   IO 0 0 put
   IO 1 n1 1 sub put
   IO 2 n1 put
   IO 3 n1 n2 add 1 sub put
end
} def

/solidnombreinfaces {
1 dict begin
   /solid exch def
   solid solidwithinfaces {
      /IO solid solidgetinouttable def
      IO 3 get IO 2 get sub 1 add
   } {
      0
   } ifelse
end
} def

/solidnombreoutfaces {
1 dict begin
   /solid exch def
   /IO solid solidgetinouttable def
   IO 1 get IO 0 get sub 1 add
end
} def

%% syntaxe : solid solidgetinfaces --> array
/solidgetinfaces {
4 dict begin
   /solid exch def
   solid issolid not {
      (Error : mauvais type d argument dans solidgetinfaces) ==
      quit
   } if
   solid solidwithinfaces {
      /IO solid solidgetinouttable def
      /F solid solidgetfaces def
      /n1 IO 2 get def
      /n2 IO 3 get def
      /n n2 n1 sub 1 add def
      F n1 n getinterval
   } {
      []
   } ifelse
end
} def

%% syntaxe : solid solidgetoutfaces --> array
/solidgetoutfaces {
4 dict begin
   /solid exch def
   solid issolid not {
      (Error : mauvais type d argument dans solidgetoutfaces) ==
      quit
   } if
   /IO solid solidgetinouttable def
   /F solid solidgetfaces def
   /n1 IO 0 get def
   /n2 IO 1 get def
   /n n2 n1 sub 1 add def
   F n1 n getinterval
end
} def

%% /tracelignedeniveau? false def
%% /hauteurlignedeniveau 1 def
%% /couleurlignedeniveau {rouge} def
%% /linewidthlignedeniveau 4 def

/solidgridOn {
   /solidgrid true def
} def
/solidgridOff {
   /solidgrid false def
} def

%% syntaxe : solid i string solidputfcolor
%% syntaxe : solid str outputcolors
%% syntaxe : solid str1 str2 inoutputcolors
%% syntaxe : solid string n solidputncolors
%% syntaxe : solid array solidputincolors --> -
%% syntaxe : solid array solidputoutcolors --> -
%% syntaxe : solid solidgetincolors --> array
%% syntaxe : solid solidgetoutcolors --> array

%% syntaxe : solid array solidputinfaces --> -
%% syntaxe : solid array solidputoutfaces --> -
%% syntaxe : solid solidgetinfaces --> array
%% syntaxe : solid solidgetoutfaces --> array

%% syntaxe : solid1 solid2 solidfuz -> solid

%% syntaxe : solid i solidgetsommetsface -> array
%% array = tableau de points 3d
/solidgetsommetsface {
1 dict begin
   /i exch def
   /solid exch def
   /F solid i solidgetface def
   [
      0 1 F length 1 sub {
         /k exch def
         solid F k get solidgetsommet
      } for
   ]
end
} def

%% syntaxe : solid index table solidputface -> -
/solidputface {
1 dict begin
   /table exch def
   /i exch def
   solidgetfaces i table put
end
} def

%% syntaxe : solid table solidaddface -> -
%% syntaxe : solid table (couleur) solidaddface -> -
%% on ne se preoccupe pas des faces internes
/solidaddface {
6 dict begin
   dup isstring {
      /lac@uleur exch def
   } {
      /lac@uleur () def
   } ifelse
   /table exch def
   /solid exch def
   /IO solid solidgetinouttable def
   /n2 IO 1 get def
   /FC solid solidgetoutcolors def
   IO 1 n2 1 add put
   solid [ solid solidgetfaces aload pop table ] solidputfaces
   solid IO solidputinouttable
%   solid solidnombrefaces
    solid [
      FC aload pop lac@uleur
    ] solidputoutcolors
end
} def

/solidnombrefaces {
1 dict begin
   /solid exch def
   solid solidnombreinfaces
   solid solidnombreoutfaces
   add 
end
} def

%% syntaxe : solid M solidaddsommetexterne -> -
%% on ajoute le sommet sans se preoccuper de rien
/solidaddsommetexterne {
2 dict begin
   /M defpoint3d
   /solid exch def
   solid
   [ solid solidgetsommets aload pop M ]
   solidputsommets
end
} def

%% syntaxe : solid array solidaddsommets -> -
/solidaddsommets {
2 dict begin
   /table exch def
   /solid exch def
   /n table length 3 idiv def
   0 1 0 {
      /i exch def
      solid table i getp3d solidaddsommet pop
   } for
end
} def

%% syntaxe : solid M solidaddsommet -> k
%% on ajoute le sommet M. Si il est deja sur une arete,
%% on l incorpore a la face concernee 
%% s il est deja present, on ne le rajoute pas.
%% Renvoie l indice du sommet rajoute.
/solidaddsommet {
10 dict begin
   /M defpoint3d
   /solid exch def
   /nbf solid solidnombrefaces def
   /N solid solidnombresommets def
   /sortie -1 def
   %% le sommet est-il deja dans la structure
   0 1 N 1 sub {
      /i exch def
%%       (addsommet) ==
%%       solid i solidgetsommet == == == 
%%       M == == ==
%%       solid i solidgetsommet M eqp3d ==
   
%      solid i solidgetsommet M eqp3d {
      solid i solidgetsommet M distance3d 1e-5 le {
         %% oui => c est fini
         /sortie i store
      } if
   } for
   sortie 0 lt {
      %% non => on le rajoute
      /sortie N def
      solid M solidaddsommetexterne
      %% est il sur une arete deja codee
      0 1 nbf 1 sub {
         %% face d indice i
         /i exch def
         solid i solidgetface /F exch def
         /nbsf F length def
         0 1 nbsf 1 sub {
            /j exch def
            M
            solid j i solidgetsommetface 
            solid j 1 add nbsf mod i solidgetsommetface 
            point3dsursegment {
               %% il est sur l arete concernee
               solid i [
                  0 1 j {
                     /k exch def
                     F k get
                  } for
                  N
                  j 1 add nbsf mod dup 0 eq {
                     pop
                  } {
                     1 nbsf 1 sub {
                        /k exch def
                        F k get
                     } for
                  } ifelse
               ]  solidputface
               exit
            } if
         } for 
      } for
   } if
   sortie
end
} def

%%%%% ### solidrmsommet ###
%% syntaxe : solid i solidrmsommet -> -
/solidrmsommet {
5 dict begin
   /i exch def
   /solid exch def
   solid issolid not {
      (Erreur : mauvais type d argument dans solidrmsommet) ==
      quit 
   } if
   solid i solidsommetsadjsommet length 0 gt {
      (Erreur : sommet non isole dans solidrmsommet) ==
      quit 
   } if

   %% on s occupe des sommets
   /n solid solidnombresommets def
   /S [
      0 1 n 1 sub {
         /j exch def
         j i ne {
            solid j solidgetsommet
         } if
      } for
   ] def
   solid S solidputsommets
   %% on s occupe des faces
   /n solid solidnombrefaces def
   /F [
      0 1 n 1 sub {
         %% face d indice j
         /j exch def
         /Fj solid j solidgetface def
         [0 1 Fj length 1 sub {
            %% sommet d indice k de la face Fj
            /k exch def
            Fj k get dup i gt {
               1 sub
            } if
         } for]
      } for
   ] def
   solid F solidputfaces
end
} def

%%%%% ### solidsommetsadjsommet ###
%% syntaxe : solid i solidsommetsadjsommet --> array
%% array est le tableau des indices des sommets adjacents au
%% sommet d indice i
/solidsommetsadjsommet {
6 dict begin
   /no exch def
   /solid exch def
   solid no solidfacesadjsommet /facesadj exch def
   /sommetsadj [] def
   /nbadj facesadj length def
   0 1 nbadj 1 sub {
      /j exch def
      %% examen de la jieme face
      %/j 0 def
      /F solid facesadj j get solidgetface def
      /nbsommetsface F length def
      no F in {
         /index exch def
         /i1 F index 1 sub nbsommetsface modulo get def
         /i2 F index 1 add nbsommetsface mod get def
         %% si i1 n est pas deja note, on le rajoute
         i1 sommetsadj in {
            pop
         } {
            /sommetsadj [ sommetsadj aload pop i1 ] store
         } ifelse
         %% si i2 n est pas deja note, on le rajoute
         i2 sommetsadj in {
            pop
         } {
            /sommetsadj [ sommetsadj aload pop i2 ] store
         } ifelse
      } {
         (Error : bug dans solidsommetsadjsommet) ==
         quit
      } ifelse
   } for
   sommetsadj
end
} def

%%%%% ### solidfacesadjsommet ###
%% syntaxe : solid i solidfacesadjsommet --> array
%% array est le tableau des indices des faces adjacentes au
%% sommet d indice i
/solidfacesadjsommet {
6 dict begin
   /no exch def
   /solid exch def
   /n solid solidnombrefaces def
   /indicesfacesadj [] def
   0 1 n 1 sub {
      /j exch def
      /F solid j solidgetface def
      no F in {
         pop
         /indicesfacesadj [ indicesfacesadj aload pop j ] store
      } if
   } for
   indicesfacesadj
end
} def

%%%%% ### ordonnepoints3d ###
%% syntaxe : array1 M ordonnepoints3d --> array2
%% array1 = tableau de points 3d coplanaires (plan P)
%% M = point3d indiquant la direction de la normale a P
%% array2 = les indices des points de depart, ranges dans le 
%% sens trigo par rapport a la normale
/ordonnepoints3d {
5 dict begin
   /M defpoint3d
   /table exch def
   table isobarycentre3d /G defpoint3d
   %% calcul de la normale
   table 0 getp3d /ptref defpoint3d
   table 1 getp3d /A defpoint3d
   G ptref vecteur3d
   G A vecteur3d
   vectprod3d /vecteurnormal defpoint3d
   vecteurnormal G M vecteur3d scalprod3d 0 lt {
      vecteurnormal -1 mulv3d /vecteurnormal defpoint3d
   } if
   %% la table des angles
   table duparray exch pop
   {1 dict begin
      /M defpoint3d
      G ptref vecteur3d
      G M vecteur3d
      vecteurnormal angle3doriente
   end} papply3d
%   [0 1 table length 3 idiv 1 sub {} for]
%   exch
    doublebubblesort pop
end
} def

%%%%% ### fin insertion ###

%% /tracelignedeniveau? false def
%% /hauteurlignedeniveau 1 def
%% /couleurlignedeniveau {rouge} def
%% /linewidthlignedeniveau 4 def
%% 
%% /solidgrid true def
%% /aretescachees true def
%% /defaultsolidmode 2 def

%% syntaxe : alpha beta r h newpie --> solid
/newpie {
6 dict begin
   [[/resolution /nbetages] [8 1] [10 1] [12 1] [18 3] [36 5]] gestionsolidmode
   /h exch def
   /r exch def
   /beta exch def
   /alpha exch def
   [
      0 0
%      alpha cos r mul alpha sin r mul
      alpha beta {1 dict begin /t exch def t cos r mul t sin r mul end} CourbeR2+
   ] 0 h [nbetages] newprismedroit
end
} def

%%%%% ### newsolid ###
%% syntaxe : newsolid --> depose le solide nul sur la pile
/newsolid {
   [] [] generesolid
} def

%%%%% ### generesolid ###
/generesolid {
2 dict begin
   /F exch def
   /S exch def
   [S F [F length {()} repeat] [0 F length 1 sub -1 -1]]
end
} def

%%%%% ### nullsolid ###
%% syntaxe : solide nullsolid -> booleen, vrai si le solide est nul
/nullsolid {
1 dict begin
   /candidat exch def
   candidat issolid not {
      (Error type argument dans "nullsolid") ==
      quit
   } if
   candidat solidgetsommets length 0 eq {
      true
   } {
      false
   } ifelse
end
} def

%%%%% ### solidnombreoutfaces ###
/solidnombreoutfaces {
4 dict begin
   /solid exch def
   solid issolid not {
      (Error : mauvais type d argument dans solidnombreoutfaces) ==
      quit
   } if
   solid nullsolid {
      0
   } {
      /IO solid solidgetinouttable def
      IO 1 get
      IO 0 get sub
      1 add
   } ifelse
end
} def

%%%%% ### solidnombreinfaces ###
/solidnombreinfaces {
4 dict begin
   /solid exch def
   solid issolid not {
      (Error : mauvais type d argument dans solidnombreinfaces) ==
      quit
   } if
   solid solidwithinfaces {
      /IO solid solidgetinouttable def
      IO 3 get
      IO 2 get sub
      1 add
   } {
      0
   } ifelse
end
} def

%%%%% ### solidtests ###
%% syntaxe : solid solidwithinfaces --> bool, true si le solide est vide
/solidwithinfaces {
2 dict begin
   /solid exch def
   solid issolid not {
      (Error : mauvais type d argument dans solidwithinfaces) ==
      quit
   } if
   /table solid solidgetinouttable def
   table 2 get -1 ne {
      true
   } {
      false
   } ifelse
end
} def

%%%%% ### solidgetsommet ###
%% syntaxe : solid i j solidgetsommetface --> sommet i de la face j
/solidgetsommetface {
6 dict begin
   /j exch def
   /i exch def
   /solid exch def
   solid issolid not {
      (Error : mauvais type d argument dans solidgetsommetface) ==
      quit
   } if
   /table_faces solid solidgetfaces def
   /table_sommets solid solidgetsommets def
   /k table_faces j get i get def
   table_sommets k getp3d
end
} def

%% syntaxe : solid i solidgetsommetsface --> array, tableau des
%% sommets de la face i du solide
/solidgetsommetsface {
6 dict begin
   /i exch def
   /solid exch def
   solid issolid not {
      (Error : mauvais type d argument dans solidgetsommetsface) ==
      quit
   } if
   /table_faces solid solidgetfaces def
   /table_sommets solid solidgetsommets def
   /table_indices table_faces i get def
   [
      0 1 table_indices length 1 sub {
         /j exch def
         table_sommets table_indices j get getp3d
      } for
   ]
end
} def

%% syntaxe : solid i solidgetsommet --> sommet i du solide
/solidgetsommet {
3 dict begin
   /i exch def
   /solid exch def
   solid issolid not {
      (Error : mauvais type d argument dans solidgetsommet) ==
      quit
   } if
   /table_sommets solid solidgetsommets def
   table_sommets i getp3d
end
} def

%%%%% ### solidcentreface ###
%% syntaxe : solid i solidcentreface --> M
/solidcentreface {
   solidgetsommetsface isobarycentre3d
} def

%%%%% ### solidnombre ###
/solidnombresommets {
   solidgetsommets length 3 idiv
} def

/solidfacenombresommets {
   solidgetface length
} def

/solidnombrefaces {
   solidgetfaces length
} def

%%%%% ### solidshowsommets ###
/solidshowsommets {
8 dict begin
   dup issolid not {
      %% on a un argument
      /option exch def
   } if
   /sol exch def
   /n sol solidnombresommets def
   /m sol solidnombrefaces def
   currentdict /option known not {
      /option [0 1 n 1 sub {} for] def
   } if
   0 1 option length 1 sub {
      /k exch def
      option k get /i exch def       %% indice du sommet examine
      sol i solidgetsommet point3d
   } for
end
} def

%%%%% ### solidnumsommets ###
/solidnumsommets {
8 dict begin
   Font findfont 10 scalefont setfont
   dup issolid not {
      %% on a un argument
      /option exch def
   } if
   /sol exch def
   /n sol solidnombresommets def
   /m sol solidnombrefaces def
   currentdict /option known not {
      /option [0 1 n 1 sub {} for] def
   } if
   /result [
      n {false} repeat
   ] def
   0 1 option length 1 sub {
      /k exch def
      option k get /i exch def       %% indice du sommet examine
      0 1 m 1 sub {
         /j exch def %% indice de la face examinee
         i sol j solidgetface in {
            %% le sommet i est dans la face j
            pop
            exit
         } if
      } for
      %% le sommet i est dans la face j
      sol j solidcentreface /G defpoint3d
      sol i solidgetsommet /S defpoint3d
      i (   ) cvs
      G S vecteur3d normalize3d
      15 dup ptojpoint pop
      mulv3d
      S addv3d
      3dto2d cctext 
   } for
end
} def

%%%%% ### gestionsolidmode ###
%% table = [ [vars] [mode0] [mode1] [mode2] [mode3] [mode4] ]
/gestionsolidmode {
5 dict begin
   /table exch def
   dup xcheck {
      /mode exch def
   } {
      dup isarray {
         /tableaffectation exch def
         /mode -1 def
      } {
         /mode defaultsolidmode def
      } ifelse
   } ifelse
   /vars table 0 get def
   /nbvars vars length def
   mode 0 ge {
      /tableaffectation table mode 1 add 5 min get def
   } if
   0 1 nbvars 1 sub {
      /i exch def
      vars i get
      tableaffectation i get
   } for
   nbvars 
end
   {def} repeat
} def

%%%%% ### solidfuz ###
%% syntaxe : solid1 solid2 solidfuz -> solid
/solidfuz {
5 dict begin
   /solid2 exch def
   /solid1 exch def
   /S1 solid1 solidgetsommets def
   /S2 solid2 solidgetsommets def
   /n S1 length 3 idiv def

   %% les sommets
   /S S1 S2 append def

   %% les faces internes et leurs couleurs
   /FI1 solid1 solidgetinfaces def
   /FIC1 solid1 solidgetincolors def
   solid2 solidnombreinfaces 0 eq {
      /FI2 [] def
      /FIC2 [] def
   } {
      /FI2 solid2 solidgetinfaces {{n add} apply} apply def
      /FIC2 solid2 solidgetincolors def
   } ifelse
   /FI [FI1 aload pop FI2 aload pop] def
   /FIC [FIC1 aload pop FIC2 aload pop] def

   %% les faces externes et leurs couleurs
   /FO1 solid1 solidgetoutfaces def
   /FOC1 solid1 solidgetoutcolors def
   /FO2 solid2 solidgetoutfaces {{n add} apply} apply def
   /FOC2 solid2 solidgetoutcolors def
   /FO [FO1 aload pop FO2 aload pop] def
   /FOC [FOC1 aload pop FOC2 aload pop] def

   /F [FO aload pop FI aload pop] def
   /FC [FOC aload pop FIC aload pop] def
   /IO [
      0 FO length 1 sub
      FI length 0 gt {
         dup 1 add dup FI length add 1 sub
      } {
         -1 -1
      } ifelse
   ] def

   S F generesolid
   dup FC solidputfcolors
   dup IO solidputinouttable
end
} def

%%%%% ### solidnormaleface ###
%% syntaxe : solid i solidnormaleface --> u, vecteur normale a la
%% face d indice i du solide
/solidnormaleface {
4 dict begin
   /i exch def
   /solid exch def
   solid issolid not {
      (Error : mauvais type d argument dans solidgetsommetface) ==
      quit
   } if
%%    solid 0 i solidgetsommetface /G defpoint3d
%%    G
%%    solid 1 i solidgetsommetface
%%    vecteur3d
%%    G
%%    solid 2 i solidgetsommetface
%%    vecteur3d

   /n solid i solidfacenombresommets def
   solid i solidcentreface /G defpoint3d
  %% debug %%   G 3dto2d point
   G
   solid 0 i solidgetsommetface
   /A defpoint3d
  %   gsave bleu A point3d grestore
   A
   vecteur3d normalize3d
   G
   solid 1 i solidgetsommetface
   /A defpoint3d
  %   gsave orange A point3d grestore
   A
   vecteur3d normalize3d
   vectprod3d
   /resultat defpoint3d
   resultat normalize3d
end
} def

%%%%% ### solidtransform ###
%% syntaxe : solid1 {f} solidtransform --> solid2, solid2 est le
%% transforme de solid1 par la transformation f : R^3 -> R^3
/solidtransform {
3 dict begin
   /@f exch def
   /solid exch def
   solid issolid not {
      (Error : mauvais type d argument dans solidtransform) ==
      quit
   } if
   /les_sommets
      solid solidgetsommets {@f} papply3d
   def
   solid les_sommets solidputsommets
   solid
end
} def

%%%%% ### solidputcolor ###
%% syntaxe : solid i string solidputfcolor
/solidputfcolor {
3 dict begin
   /str exch def
   /i exch def
   /solid exch def
   /FC solid solidgetfcolors def
   i FC length lt {
      FC i str put
   } if
end
} def

%% syntaxe : solid solidgetincolors --> array
/solidgetincolors {
3 dict begin
   /solid exch def
   solid issolid not {
      (Error : mauvais type d argument dans solidgetincolors) ==
      quit
   } if
   solid solidwithinfaces {
      /fcol solid solidgetfcolors def
      /IO solid solidgetinouttable def
      /n1 IO 2 get def
      /n2 IO 3 get def
      /n n2 n1 sub 1 add def
      fcol n1 n getinterval
   } {
      []
   } ifelse
end
} def

%% syntaxe : solid solidgetoutcolors --> array
/solidgetoutcolors {
3 dict begin
   /solid exch def
   solid issolid not {
      (Error : mauvais type d argument dans solidgetoutcolors) ==
      quit
   } if
   /fcol solid solidgetfcolors def
   /IO solid solidgetinouttable def 
   /n1 IO 0 get def
   /n2 IO 1 get def
   /n n2 n1 sub 1 add def
   fcol n1 n getinterval 
end
} def
 
%% syntaxe : solid array solidputincolors --> -
/solidputincolors {
4 dict begin
   /newcolorstable exch def
   /solid exch def
   solid issolid not {
      (Error : mauvais type d argument dans solidputincolors) ==
      quit
   } if
   /n newcolorstable length def
   n solid solidnombreinfaces ne {
      (Error : mauvaise longueur de tableau dans solidputincolors) ==
      quit
   } if
   n 0 ne {
      /FC solid solidgetfcolors def
      /IO solid solidgetinouttable def
      /n1 IO 2 get def
      FC n1 newcolorstable putinterval
   } if
end
} def

%% syntaxe : solid array solidputoutcolors --> -
/solidputoutcolors {
4 dict begin
   /newcolorstable exch def
   /solid exch def
   solid issolid not {
      (Error : mauvais type d argument dans solidputoutcolors) ==
      quit
   } if
   /n newcolorstable length def
   n solid solidnombreoutfaces ne {
      (Error : mauvaise longueur de tableau dans solidputoutcolors) ==
      quit
   } if
   n 0 ne {
      /FC solid solidgetfcolors def
      /IO solid solidgetinouttable def
      /n1 IO 0 get def
      FC n1 newcolorstable putinterval
   } if
end
} def

%% syntaxe : solid str outputcolors
/outputcolors {
5 dict begin
   /color exch def
   /solid exch def
   solid issolid not {
      (Error : mauvais type d argument dans inoutputcolors) ==
      quit
   } if
   /n solid solidnombreoutfaces def
   solid [ n {color} repeat ] solidputoutcolors
end
} def

%% syntaxe : solid str inputcolors
/inputcolors {
5 dict begin
   /color exch def
   /solid exch def
   solid issolid not {
      (Error : mauvais type d argument dans inoutputcolors) ==
      quit
   } if
   /n solid solidnombreinfaces def
   solid [ n {color} repeat ] solidputincolors
end
} def

%% syntaxe : solid str1 str2 inoutputcolors
/inoutputcolors {
5 dict begin
   /colout exch def
   /colin exch def
   /solid exch def
   solid colin inputcolors
   solid colout outputcolors
end
} def

%% syntaxe : solid array solidputoutcolors --> -
/solidputoutcolors {
4 dict begin
   /newcolorstable exch def
   /solid exch def
   solid issolid not {
      (Error : mauvais type d argument dans solidputoutcolors) ==
      quit
   } if
   /n newcolorstable length def
   n solid solidnombreoutfaces ne {
      (Error : mauvaise longueur de tableau dans solidputoutcolors) ==
      quit
   } if
   n 0 ne {
      /FC solid solidgetfcolors def
      /IO solid solidgetinouttable def
      /n1 IO 0 get def
      FC length n n1 add lt {
         solid newcolorstable solidputfcolors
      } {
         FC n1 newcolorstable putinterval
      } ifelse
   } if
end
} def

/solidputcolors {
3 dict begin
   2 copy pop
   isstring {
      inoutputcolors
   } {
      outputcolors
   } ifelse
end
} def

%%%%% ### solidputhuecolors ###
%% syntaxe : solid table solidputhuecolors --> -
/solidputhuecolors {
1 dict begin
   2 copy pop
   solidgetinouttable /IO exch def
   IO 0 get
   IO 1 get
   s@lidputhuec@l@rs
end
} def

/solidputinhuecolors {
2 dict begin
   /table exch def
   /solid exch def
   solid solidgetinouttable /IO exch def
   solid solidwithinfaces {
      solid table
      IO 2 get
      IO 3 get
      s@lidputhuec@l@rs
   } if
end
} def

/solidputinouthuecolors {
1 dict begin
   2 copy pop
   solidgetinouttable /IO exch def
   IO 0 get
   IO 3 get IO 1 get max
   s@lidputhuec@l@rs
end
} def

%% syntaxe : solid table n1 n2 s@lidputhuec@l@rs --> -
%% affecte les couleurs des faces d indice n1 a n2 du solid solid, par
%% un degrade defini par la table.
 /s@lidputhuec@l@rs {
9 dict begin
   /n2 exch def
   /n1 exch def
   /table exch def
   /solid exch def
   /n n2 n1 sub def

   table length 2 eq {
       /a0 table 0 get def
       /a1 table 1 get def
       a1 isstring {
          /lacouleurdepart {
             gsave
                [a0 cvx exec] length 0 eq {
                   a0 cvx exec currentrgbcolor
                } {
                   a0 cvx exec
                } ifelse 
             grestore
          } def
          /lacouleurarrivee {
             gsave
                [a1 cvx exec] length 0 eq {
                   a1 cvx exec currentrgbcolor
                } {
                   a1 cvx exec
                } ifelse 
             grestore
          } def
          /table [lacouleurdepart lacouleurarrivee] def
       } {
          /A {a0 i a1 a0 sub mul n 1 sub div add} def
          /B {1} def
          /C {1} def
          /D {} def
          /espacedecouleurs (sethsbcolor) def
       } ifelse
   } if

   table length 4 eq {
       /a0 table 0 get def
       /a1 table 1 get def
       /A {a0 i a1 a0 sub mul n 1 sub div add} def
       /B table 2 get def
       /C table 3 get def
       /D {} def
       /espacedecouleurs (sethsbcolor) def
   } if

   table length 6 eq {
       /a0 table 0 get def
       /b0 table 1 get def
       /c0 table 2 get def
       /a1 table 3 get def
       /b1 table 4 get def
       /c1 table 5 get def
       /A {a0 i a1 a0 sub mul n 1 sub div add} def
       /B {b0 i b1 b0 sub mul n 1 sub div add} def
       /C {c0 i c1 c0 sub mul n 1 sub div add} def
       /D {} def
       /espacedecouleurs (setrgbcolor) def
   } if

   table length 7 eq {
       /a0 table 0 get def
       /b0 table 1 get def
       /c0 table 2 get def
       /a1 table 3 get def
       /b1 table 4 get def
       /c1 table 5 get def
       /A {a0 i a1 a0 sub mul n 1 sub div add} def
       /B {b0 i b1 b0 sub mul n 1 sub div add} def
       /C {c0 i c1 c0 sub mul n 1 sub div add} def
       /D {} def
       /espacedecouleurs (sethsbcolor) def
   } if

   table length 8 eq {
       /a0 table 0 get def
       /b0 table 1 get def
       /c0 table 2 get def
       /d0 table 3 get def
       /a1 table 4 get def
       /b1 table 5 get def
       /c1 table 6 get def
       /d1 table 7 get def
       /A {a0 i a1 a0 sub mul n 1 sub div add} def
       /B {b0 i b1 b0 sub mul n 1 sub div add} def
       /C {c0 i c1 c0 sub mul n 1 sub div add} def
       /D {d0 i d1 d0 sub mul n 1 sub div add} def
       /espacedecouleurs (setcmykcolor) def
   } if

   n1 1 n2 {
      /i exch def
      solid i
      [A B C D] espacedecouleurs astr2str
      solidputfcolor
   } for
   
end
} def

%%%%% ### solidrmface ###
%% syntaxe : solid i solidrmface -> -
/solidrmface {
5 dict begin
   /i exch def
   /solid exch def
   solid issolid not {
      (Error : mauvais type d argument dans solidrmface) ==
      quit
   } if
   %% on enleve la face
   /F solid solidgetfaces def
   F length 1 sub i lt {
      (Error : indice trop grand dans solidrmface) ==
      quit
   } if
   [
      0 1 F length 1 sub {
         /j exch def
         i j ne {
            F j get
         } if
      } for
   ]
   /NF exch def
   solid NF solidputfaces
   %% on enleve la couleur correspondante
   /FC solid solidgetfcolors def
   [
      0 1 FC length 1 sub {
         /j exch def
         i j ne {
            FC j get
         } if
      } for
   ]
   /NFC exch def
   solid NFC solidputfcolors
   %% on ajuste la table inout
   /IO solid solidgetinouttable def
   solid i solidisoutface {
      IO 1 IO 1 get 1 sub put 
      solid solidwithinfaces {
         IO 2 IO 2 get 1 sub put
         IO 3 IO 3 get 1 sub put
      } if
   } if
   solid i solidisinface {
      IO 1 IO 1 get 1 sub put
      IO 2 IO 2 get 1 sub put
      IO 3 IO 3 get 1 sub put
   } if
   solid IO solidputinouttable
end
} def

%% syntaxe : solid table solidrmfaces --> -
/solidrmfaces {
2 dict begin
   /table exch bubblesort reverse def
   /solid exch def
   table {solid exch solidrmface} apply
end
} def

%%%%% ### videsolid ###
%% syntaxe : solid videsolid -> -
/videsolid {
5 dict begin
   /solid exch def
   solid issolid not {
      (Error : mauvais type d argument dans videsolid) ==
      quit
   } if
   solid solidwithinfaces not {
      /IO solid solidgetinouttable def
      /FE solid solidgetfaces def
      /n FE length def
      IO 2 n put
      IO 3 2 n mul 1 sub put
      solid IO solidputinouttable
      %% on inverse chaque face
      /FI FE {reverse} apply def
      solid FE FI append solidputfaces
      %% et on rajoute autant de couleurs vides que de faces
      /FEC solid solidgetfcolors def
%      /FIC [FI length {()} repeat] def
%      solid FEC FIC append solidputfcolors
      solid FEC duparray append solidputfcolors
   } if 
end
} def

%%%%% ### solidnumfaces ###
%% syntaxe : solid array solidnumfaces
%% syntaxe : solid array bool solidnumfaces
%% array, le tableau des indices des faces a numeroter, est optionnel
%% si bool=true, on ne numerote que les faces visibles
/solidnumfaces {
5 dict begin
   dup isbool {
      /bool exch def
   } {
      /bool true def
   } ifelse
   setTimes
   dup issolid not {
      %% on a un argument
      /option exch def 
   } if
   /sol exch def
   /n sol solidnombrefaces def
   currentdict /option known not {
      /option [0 1 n 1 sub {} for] def
   } if

   0 1 option length 1 sub {
      /i exch def
      /j option i get def
      j (     ) cvs sol j bool cctextp3d
   } for
end
} def

%%%%% ### creusesolid ###
%% syntaxe : solid creusesolid -> -
/creusesolid {
5 dict begin
   /solid exch def
   solid issolid not {
      (Error : mauvais type d argument dans creusesolid) ==
      quit
   } if
   %% on enleve le fond et le chapeau
   solid 1 solidrmface
   solid 0 solidrmface
   %% on inverse chaque face
   solid videsolid
end
} def

%%%%% ### fin insertion ###

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%                 dessin des solides                 %%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%%%%% ### solidisinface ###
%% syntaxe : solid i solidisinface --> bool
%% true si i est l indice d une face interne, false sinon
/solidisinface {
4 dict begin
   /i exch def
   solidgetinouttable /IO exch def
   /n1 IO 2 get def
   /n2 IO 3 get def
   n1 i le 
   i n2 le and
end
} def

%%%%% ### solidisoutface ###
%% syntaxe : solid i solidisoutface --> bool
%% true si i est l indice d une face externe, false sinon
/solidisoutface {
4 dict begin
   /i exch def
   solidgetinouttable /IO exch def
   /n1 IO 0 get def
   /n2 IO 1 get def
   n1 i le 
   i n2 le and
end
} def

%%%%% ### planvisible ###
%% syntaxe : A k planvisible? --> true si le plan est visible
/planvisible? {
4 dict begin
   /normale_plan defpoint3d
   /origine defpoint3d
   /ligne_de_vue {
      origine
      GetCamPos
      vecteur3d
   } def
   ligne_de_vue normale_plan scalprod3d 0 gt
end
} def

%%%%% ### solidlight ###
/setlightintensity {
   /lightintensity exch def
} def

/setlightsrc {
   /lightsrc defpoint3d
} def

/setlight {
1 dict begin
gsave
   exec
   [ currentrgbcolor ] /lightcolor exch 
grestore
end
def
} def

%%%%% ### drawsolid ###
/solidlightOn {
   /s@lidlight true def
} def
/solidlightOff {
   /s@lidlight false def
} def
solidlightOff

%% syntaxe : solid i solidfacevisible? --> true si la face est visible
/solidfacevisible? {
4 dict begin
   /i exch def
   /solid exch def
   solid issolid not {
      (Error : mauvais type d argument dans solidgetsommetface) ==
      quit
   } if
   solid i solidgetface length 2 le {
      true
   } {
      /ligne_de_vue {
         solid i solidcentreface
         GetCamPos
         vecteur3d
      } def
   
      /normale_face {
         solid i solidnormaleface
      } def
      ligne_de_vue normale_face scalprod3d 0 gt
   } ifelse
end
} def

%% syntaxe : solid i affectecouleursolid_facei --> si la couleur de
%% la face i est definie, affecte fillstyle a cette couleur
/affectecouleursolid_facei {
3 dict begin
   /i exch def
   /solid exch def
   solid solidgetfcolors /FC exch def
   FC length 1 sub i ge {
      FC i get length 1 ge {
         /fillstyle FC i get ( Fill) append cvx
         solidgrid not {
            FC i get cvx exec
         } if
         true
      } {
         false
      } ifelse
   } {
      false
   } ifelse
end
{def} if
} def

%% syntaxe : solid i dessinefacecachee
/dessinefacecachee {
11 dict begin
   /i exch def
   /solid exch def
   solid issolid not {
      (Error : mauvais type d argument dans dessinefacecachee) ==
      quit
   } if

   /F solid solidgetfaces def
   /S solid solidgetsommets def

   %% face cachee => on prend chacune des aretes de la face et on
   %% la dessine
   4 dict begin
      /n F i get length def %% nb de sommets de la face
      0 1 n 1 sub {
         /k exch def
         /k1 F i k get_ij def              %% indice sommet1
         /k2 F i k 1 add n mod get_ij def  %% indice sommet2
         gsave
            currentlinewidth .5 mul setlinewidth
            pointilles
            [S k1 getp3d
            S k2 getp3d sortp3d] ligne3d
         grestore
      } for

   %% trace de la ligne de niveau
   solidintersectiontype 0 ge {
      /face_a_dessiner [  %% face visible : F [i]
         0 1 n 1 sub {
            /j exch def
            solid j i solidgetsommetface
         } for
      ] def 
      0 1 solidintersectionplan length 1 sub {
         /k exch def
         /lignedeniveau [] def
         gsave
            pointilles
            k solidintersectionlinewidth length lt {
               solidintersectionlinewidth k get setlinewidth
            } {
               solidintersectionlinewidth 0 get setlinewidth
            } ifelse
            k solidintersectioncolor length lt {
               solidintersectioncolor k get cvx exec
            } {
               solidintersectioncolor 0 get cvx exec
            } ifelse
            0 1 n 1 sub {
               /j exch def
               face_a_dessiner j getp3d
               face_a_dessiner j 1 add n mod getp3d
               solidintersectionplan k get
               dup isarray {
                  segment_inter_plan
               } {
                  segment_inter_planz
               } ifelse {
               1 dict begin
                  /table exch def
                  table length 6 eq {
                     /lignedeniveau table store
                     exit
                  } {
                     /lignedeniveau [ 
                        lignedeniveau aload pop 
                        table 0 getp3d
                     ] store
                  } ifelse
               end
               } if
            } for
            
            %% dessin de la ligne
            lignedeniveau length 4 ge {
               [lignedeniveau aload pop sortp3d] ligne3d
            } if
         grestore
      } for         
   } if
   
   end
end
} def

%% syntaxe : solid i dessinefacevisible
/dessinefacevisible {
8 dict begin
   /i exch def
   /solid exch def
   solid issolid not {
      (Error : mauvais type d argument dans dessinefacevisible) ==
      quit
   } if
   /F solid solidgetfaces def
   /S solid solidgetsommets def

   /n F i get length def %% nb de sommets de la face

   startest {
      s@lidlight {
         /coeff
            lightintensity
            solid i solidnormaleface normalize3d
            solid i solidcentreface lightsrc vecteur3d normalize3d
            scalprod3d mul
            0 max 1 min
         def
         /lightcolor where {
            pop
            /lacouleur lightcolor def
         } {
            /lacouleur [
               gsave
                  solid solidgetfcolors i get cvx exec currentrgbcolor
               grestore
            ] def
         } ifelse
         /fillstyle {
             lacouleur {coeff mul} apply setcolor Fill
         } def
         solidgrid not {
            lacouleur {coeff mul} apply setcolor
         } if
      } {
         n 2 eq {
            1 dict begin
               solidgridOff
               solid i affectecouleursolid_facei
            end
         } {
            solid i affectecouleursolid_facei
         } ifelse
      } ifelse
   } if

   /face_a_dessiner [  %% face visible : F [i]
      0 1 n 1 sub {
         /j exch def
         solid j i solidgetsommetface
      } for
   ] def 
   face_a_dessiner polygone3d

   %% trace de la ligne de niveau
   solidintersectiontype 0 ge {
      0 1 solidintersectionplan length 1 sub {
         /k exch def
         /lignedeniveau [] def
         gsave
            k solidintersectionlinewidth length lt {
               solidintersectionlinewidth k get setlinewidth
            } {
               solidintersectionlinewidth 0 get setlinewidth
            } ifelse
            k solidintersectioncolor length lt {
               solidintersectioncolor k get cvx exec
            } {
               solidintersectioncolor 0 get cvx exec
            } ifelse
            0 1 n 1 sub {
               /j exch def
               face_a_dessiner j getp3d
               face_a_dessiner j 1 add n mod getp3d
               solidintersectionplan k get
               dup isarray {
                  segment_inter_plan
               } {
                  segment_inter_planz
               } ifelse {
               1 dict begin
                  /table exch def
                  /lignedeniveau [ 
                     lignedeniveau aload pop 
                     table 0 getp3d
                     table length 4 ge {
                        table 1 getp3d
                     } if
                  ] store
               end
               } if
            } for
            
            %% dessin de la ligne
            lignedeniveau length 4 ge {
               solid i solidisinface {
                  pointilles 
               } if
               lignedeniveau ligne3d
            } if
         grestore
      } for         
   } if
      
end
} def

/drawsolid* {
1 dict begin
   /startest {true} def
   drawsolid
end
} def

/peintrealgorithme false def

/drawsolid** {
2 dict begin
   /aretescachees false def
   /peintrealgorithme true def
   drawsolid*
end
} def

%% syntaxe : solid array drawsolid
%% array est en option, il indique les faces triees
/drawsolid {
8 dict begin
   dup issolid not {
      /ordre exch def
   } if
   /solid exch def
   solid issolid not {
      (Error : mauvais type d argument dans drawsolid) ==
      quit
   } if
   solid nullsolid not {
      solid solidgetfaces
      /F exch def
      solid solidgetsommets
      /S exch def
      /n S length 3 idiv def

      currentdict /ordre known not {
         peintrealgorithme {
            %% tri des indices des faces par distance decroissante
            [
               0 1 F length 1 sub {
                  /i exch def
                  solid i solidcentreface
                  GetCamPos
                  distance3d
               } for
            ] doublequicksort pop reverse
         } {
            [
               0 1 F length 1 sub {
               } for
            ]
         } ifelse
         /ordre exch def
      } if

      0 1 F length 1 sub {
         /k exch def
         /i ordre k get def
         gsave
            solid i solidfacevisible? {
               solid i dessinefacevisible
            } if
         grestore
      } for
      aretescachees {
         0 1 F length 1 sub {
            /k exch def
            /i ordre k get def
            gsave
               solid i solidfacevisible? not {
                  solid i dessinefacecachee
               } if 
            grestore
         } for
      } if

%%       %% si on veut repasser les traits des faces visibles
%%       0 1 F length 1 sub {
%%          /k exch def
%%          /i ordre k get def
%%          gsave
%%          1 dict begin
%%             /startest false def
%%             solid i solidfacevisible? {
%%             solid i dessinefacevisible
%%             } if
%%          end
%%          grestore
%%       } for
   } if
end
} def

%%%%% ### segment_inter_planz ###
%% syntaxe : A B k segment_inter_planz --> array true ou false
/segment_inter_planz {
4 dict begin
   /k exch def
   /B defpoint3d
   /A defpoint3d
   A /zA exch def pop pop
   B /zB exch def pop pop
   zA k sub zB k sub mul dup 0 gt {
      %% pas d intersection
      pop
      false
   } {
      0 eq {
         %% intersection en A ou en B
         [ 
            zA k eq {A} if
            zB k eq {B} if
         ] true
      } {
         %% intersection entre A et B
         [
            A B vecteur3d
            k zA sub zB zA sub div mulv3d
            A addv3d
         ] true
      } ifelse
   } ifelse
end
} def

%%%%% ### fin insertion ###

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%                  plans affines                     %%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%%%%% ### planaffine ###
%% plan : origine, base, range, ngrid
%% [0 0 0 [1 0 0 0 1 0] [-3 3 -2 2] [1. 1.] ]

/explan [0 0 0 [1 0 0 0 1 0 0 0 1] [-3 3 -2 2] [1. 1.] ] def

%% syntaxe : any isplan --> bool
/isplan {
1 dict begin
   /candidat exch def
   candidat isarray {
      candidat length 6 eq {
         candidat 3 get isarray {
            candidat 4 get isarray {
               candidat 5 get isarray              
            } {
               false
            } ifelse
         } {
            false
         } ifelse
      } {
         false
      } ifelse
   } {
      false
   } ifelse
end
} def

/newplanaffine {
   [0 0 0 [1 0 0 0 1 0] [-3 3 -2 2] [1 1]] 
} def

/dupplan {
4 dict begin
   /leplan exch def
   /result newplanaffine def
   result leplan plangetorigine planputorigine
   result leplan plangetbase planputbase
   result leplan plangetrange planputrange
   result leplan plangetngrid planputngrid
   result
end
} def

%% syntaxe : plantype getorigine --> x y z
/plangetorigine {
1 dict begin
   /plan exch def
   plan isplan not {
      (Erreur : mauvais type d argument dans plangetorigine) ==
      Error
   } if
   plan 0 get 
   plan 1 get 
   plan 2 get 
end
} def

%% syntaxe : plantype getbase --> [u v w]
%% ou u, v et w vecteurs de R^3
/plangetbase {
1 dict begin
   /plan exch def
   plan isplan not {
      (Erreur : mauvais type d argument dans plangetbase) ==
      Error
   } if
   plan 3 get 
end
} def

%% syntaxe : plantype getrange --> array
%% ou array = [xmin xmax ymin ymax]
/plangetrange {
1 dict begin
   /plan exch def
   plan isplan not {
      (Erreur : mauvais type d argument dans plangetrange) ==
      Error
   } if
   plan 4 get 
end
} def

%% syntaxe : plantype getngrid --> array
%% ou array = [n1 n2]
/plangetngrid {
1 dict begin
   /plan exch def
   plan isplan not {
      (Erreur : mauvais type d argument dans plangetngrid) ==
      Error
   } if
   plan 5 get 
end
} def

%% ===================

%% syntaxe : plantype x y z putorigine --> -
/planputorigine {
4 dict begin
   /z exch def
   /y exch def
   /x exch def
   /plan exch def
   plan isplan not {
      (Erreur : mauvais type d argument dans planputorigine) ==
      Error
   } if
   plan 0 x put 
   plan 1 y put 
   plan 2 z put 
end
} def

%% syntaxe : plantype [u v w] putbase --> -
%% ou u, v et w vecteurs de R^3
/planputbase {
2 dict begin
   /base exch def
   /plan exch def
   plan isplan not {
      (Erreur : mauvais type d argument dans planputbase) ==
      Error
   } if
   plan 3 base put 
end
} def

%% syntaxe : plantype array putrange --> -
%% ou array = [xmin xmax ymin ymax]
/planputrange {
2 dict begin
   /table exch def
   /plan exch def
   plan isplan not {
      (Erreur : mauvais type d argument dans planputrange) ==
      Error
   } if
   plan 4 table put 
end
} def

%% syntaxe : plantype array putngrid --> -
%% ou array = [n1 n2]
/planputngrid {
2 dict begin
   /table exch def
   /plan exch def
   plan isplan not {
      (Erreur : mauvais type d argument dans planputngrid) ==
      quit
   } if
   plan 5 table put 
end
} def

%% -3 3 -2 2 1. 1. newgrille
%% drawsolid

%orange

%% plan : origine, base, range, ngrid

%% syntaxe : plantype drawplanaffine --> -
/drawplanaffine {
5 dict begin
   /plan exch def
   plan plangetbase 
   aload pop
   /imK defpoint3d
   /imJ defpoint3d
   /imI defpoint3d
   newpath
      plan plangetrange plan plangetngrid aload pop  quadrillagexOy_
      plan plangetorigine [imI imK] false planprojpath
   Stroke
end
} def


%% %% syntaxe : [a b c d] (x0 y0 z0) alpha defeqplanaffine --> plantype
%% %% plan defini par l equation ax+by+cz+d=0, 
%% %% rotation de alpha autour de la normale (alpha est optionnel)
%% %% origine (x0, y0, z0). l origine est optionnelle
%% /defeqplanaffine {
%% 5 dict begin
%%    dup isarray {
%%       /alpha 0 def
%%    } {
%%       dup isstring {
%%          /alpha 0 def
%%       } {
%%          /alpha exch def
%%       } ifelse
%%    } ifelse
%%    dup isstring {
%%       cvx /origine exch def
%%    } if
%%    /table exch def
%%    table length 4 ne {
%%       (Erreur : mauvais type d argument dans defeqplanaffine) ==
%%       Error
%%    } if
%%    table 0 get /a exch def
%%    table 1 get /b exch def
%%    table 2 get /c exch def
%%    table 3 get /d exch def
%%    /resultat newplanaffine def
%%    [a b c alpha] normalvect_to_orthobase
%%    /imK defpoint3d
%%    /imJ defpoint3d
%%    /imI defpoint3d
%%    resultat [imI imJ imK] planputbase
%%    currentdict /origine known {
%%       origine /z exch def /y exch def /x exch def
%%       a x mul b y mul add c z mul add d add 0 ne {
%%          (Erreur : mauvaise origine dans defeqplanaffine) ==
%%          Error
%%       } if
%%       resultat origine planputorigine
%%    } {
%%       c 0 ne {
%%          resultat 0 0 d neg c div planputorigine
%%       } {
%%          a 0 ne {
%%             resultat d neg a div 0 0 planputorigine
%%          } {
%%             resultat 0 d neg b div 0 planputorigine
%%          } ifelse
%%       } ifelse
%%    } ifelse
%%    resultat
%% end
%% } def

%% /explan [0 0 0 [1 0 0 0 1 0 0 0 1] [-3 3 -2 2] [1 1] ] def
%% explan drawplanaffine
%% noir
%% /explan [0 0 2 [1 0 0 0 1 0 0 0 1] [-3 3 -2 2] [1 .5] ] def
%% explan drawplanaffine

%% orange
%% [0 0 1 -2] defeqplanaffine
%% drawplanaffine
%% noir
%% [0 0 1 0] defeqplanaffine
%% drawplanaffine
%% bleu
%% [1 1 1 0] (1 -1 0) defeqplanaffine
%% drawplanaffine
%% 

/dessinebase {
4 dict begin
gsave
   /V3 defpoint3d
   /V2 defpoint3d
   /V1 defpoint3d
   /M0 defpoint3d
   rouge
   V3 newvecteur 
   {M0 translatepoint3d} solidtransform
   drawsolid**
   bleu
   V2 newvecteur 
   {M0 translatepoint3d} solidtransform
   drawsolid**
   orange
   V1 newvecteur 
   {M0 translatepoint3d} solidtransform
   drawsolid**
grestore
end
} def

%% syntaxe : solid i solidface2eqplan --> [a b c d]
%% equation cartesienne de la face d'indice i du solide solid
/solidface2eqplan {
8 dict begin
   /i exch def
   /solid exch def
   solid i solidnormaleface
   /c exch def
   /b exch def
   /a exch def
   solid 0 i solidgetsommetface
   /z exch def
   /y exch def
   /x exch def
   [a b c a x mul b y mul add c z mul add neg]
end
} def


%% syntaxe : plantype newplan --> solid
/newplan {
5 dict begin
   /lepl@n exch def
   lepl@n plangetbase /@base exch def
   @base 0 getp3d /@U defpoint3d
   @base 1 getp3d /@V defpoint3d
   lepl@n plangetorigine /@M defpoint3d
   lepl@n plangetrange /@range exch def
   lepl@n plangetngrid /@ngrid exch def
   /@F {
   2 dict begin
      /@y exch def
      /@x exch def
      @U @x mulv3d
      @V @y mulv3d
      addv3d
      @M addv3d
   end
   } def
   @range aload pop @ngrid {@F} newsurfaceparametree
end
} def

%% syntaxe : M eqplan --> real
%% image de M par la fonction definie par l equation eqplan
/pointeqplan {
8 dict begin
   /eqplan exch def
   /@z exch def
   /@y exch def
   /@x exch def
   /@a eqplan 0 get def
   /@b eqplan 1 get def
   /@c eqplan 2 get def
   /@d eqplan 3 get def
   @a @x mul @b @y mul add @c @z mul add @d add
end
} def

/plan2eq {
6 dict begin
   /leplan exch def
   leplan plangetbase aload pop vectprod3d
   /c exch def
   /b exch def
   /a exch def
   leplan plangetorigine
   /z0 exch def
   /y0 exch def
   /x0 exch def
   [a b c a x0 mul b y0 mul add c z0 mul add neg]
end
} def

%% syntaxe : [a b c d] (x0 y0 z0) alpha defeqplanaffine --> plantype
%% plan defini par l equation ax+by+cz+d=0, 
%% rotation de alpha autour de la normale (alpha est optionnel)
%% origine (x0, y0, z0). l origine est optionnelle
/eq2plan {
5 dict begin
   dup isarray {
      /alpha 0 def
   } {
      dup isstring {
         /alpha 0 def
      } {
         /alpha exch def
      } ifelse
   } ifelse
   dup isstring {
      cvx /origine exch def
   } if
   /table exch def
   table length 4 ne {
      (Erreur : mauvais type d argument dans eq2plan) ==
      quit
   } if
   table 0 get /a exch def
   table 1 get /b exch def
   table 2 get /c exch def
   table 3 get /d exch def
   /resultat newplanaffine def
   [a b c alpha] normalvect_to_orthobase
   /imK defpoint3d
   /imJ defpoint3d
   /imI defpoint3d
   resultat [imI imJ] planputbase
   currentdict /origine known {
      origine /z exch def /y exch def /x exch def
      a x mul b y mul add c z mul add d add 0 ne {
         (Erreur : mauvaise origine dans eq2plan) ==
         quit
      } if
      resultat origine planputorigine
   } {
      c 0 ne {
         resultat 0 0 d neg c div planputorigine
      } {
         a 0 ne {
            resultat d neg a div 0 0 planputorigine
         } {
            b 0 ne {
               resultat 0 d neg b div 0 planputorigine
            } {
               (Error dans eq2plan : (a,b,c) = (0,0,0)) ==
            } ifelse
         } ifelse
      } ifelse
   } ifelse
   resultat
end
} def

/points2eqplan {
10 dict begin
   /C defpoint3d
   /B defpoint3d
   /A defpoint3d
   A B vecteur3d
   A C vecteur3d
   vectprod3d
   normalize3d
   /c exch def
   /b exch def
   /a exch def
   A
   /zA exch def
   /yA exch def
   /xA exch def
   [a b c a xA mul b yA mul add c zA mul add neg]
end
} def

%% /monplan 
%% %[0 0 -2 [1 0 0 0 1 0 0 0 1] [-3 3 -2 2] [1. 1.]]
%% [0 0 1 1] 30 eq2plan
%% def
%% 
%% [0 0 1 -2] eq2plan newplan
%% dup (blanc) outputcolors
%% monplan newplan
%% dup (blanc) outputcolors
%% solidfuz
%% drawsolid**
%% monplan plangetorigine
%% monplan plangetbase aload pop dessinebase

%% syntaxe : x0 y0 z0 [normalvect] norm2plan
/norm2plan {
9 dict begin
   normalvect_to_orthobase
   /imK defpoint3d
   /imJ defpoint3d
   /imI defpoint3d
   imK
   /c exch def
   /b exch def
   /a exch def
   /z0 exch def
   /y0 exch def
   /x0 exch def
   [a b c a x0 mul b y0 mul add c z0 mul add neg] eq2plan
   dup x0 y0 z0 planputorigine
   dup [imI imJ] planputbase
end
} def

%% syntaxe : plantype planxmarks
/planxmarks {
5 dict begin
   dup isbool {
      /mybool exch def
   } {
      /mybool true def
   } ifelse
   /leplan exch def
   leplan plangetrange aload pop
   /ymax exch def
   /ymin exch def
   /xmax exch def
   /xmin exch def
   newpath
      xmin truncate cvi 0 smoveto
      xmax truncate cvi 0 slineto
      leplan mybool projpath
   Stroke
   xmin truncate cvi xmkstep xmax truncate cvi {
      dup 0 ne {
         /x exch def
         x
         x x truncate eq {
            cvi
         } if
         dup chaine cvs exch 0 leplan mybool dctextp3d
         newpath
            x 0 smoveto
            0 2.5 rmoveto
            0 -5 rlineto
            leplan mybool projpath
         Stroke
      } {
         pop (0) 0 0 leplan mybool dltextp3d 
      } ifelse
   } for
end
} def

%% syntaxe : plantype planymarks
/planymarks {
5 dict begin
   dup isbool {
      /mybool exch def
   } {
      /mybool true def
   } ifelse
   /leplan exch def
   leplan plangetrange aload pop
   /ymax exch def
   /ymin exch def
   /xmax exch def
   /xmin exch def
   newpath
      0 ymin truncate cvi smoveto
      0 ymax truncate cvi slineto
      leplan mybool projpath
   Stroke
   ymin truncate cvi ymkstep ymax truncate cvi {
      dup 0 ne {
         /y exch def
         y
         y y truncate eq {
             cvi
         } if
         dup chaine cvs exch 0 exch leplan mybool cltextp3d
         newpath
            0 y smoveto
            2.5 0 rmoveto
            -5 0 rlineto
            leplan mybool projpath
         Stroke
      } {
         pop (0) 0 0 leplan mybool dltextp3d 
      } ifelse
   } for
end
} def

%% syntaxe : plantype planmarks
/planmarks {
1 dict begin
    dup isbool {
      /mybool exch def
   } {
      /mybool true def
   } ifelse
   dup mybool planxmarks mybool planymarks
end
} def

%% bleu
%% [-3 3 -2 2] quadrillagexOy_
%% Stroke
%% noir

%% syntaxe : [xmin xmax ymin ymax] dx dy quadrillagexOy_
/quadrillagexOy_ {
4 dict begin
   dup isarray {
      /dx 1 def
      /dy 1 def
   } {
      /dy exch def
      dup isarray {
         /dx dy def
      } {
         /dx exch def
      } ifelse
   } ifelse
   /table exch def
   table 0 get /xmin exch def
   table 1 get /xmax exch def
   table 2 get /ymin exch def
   table 3 get /ymax exch def
   ymin dy ymax {
      /y exch def
      xmin y smoveto
      xmax y slineto
   } for
   xmin dx xmax {
      /x exch def
      x ymin smoveto
      x ymax slineto
   } for
end
} def

%% syntaxe : plan [ngrid] planquadrillage
/planquadrillage {
4 dict begin
   dup isbool {
      /mybool exch def
   } {
      /mybool true def
   } ifelse
   dup isplan {
      /ngrid [1 1] def
   } {
      /ngrid exch def
   } ifelse
   /leplan exch def
   /dx ngrid 0 get def
   /dy ngrid 1 get def
   /table leplan plangetrange def
   table 0 get cvi truncate /xmin exch def
   table 1 get cvi truncate /xmax exch def
   table 2 get cvi truncate /ymin exch def
   table 3 get cvi truncate /ymax exch def
   newpath
      ymin dy ymax {
         /y exch def
         xmin y smoveto
         xmax y slineto
      } for
      xmin dx xmax {
         /x exch def
         x ymin smoveto
         x ymax slineto
      } for
      leplan mybool projpath
   Stroke
end
} def

%% syntaxe : plantype str1 str2 planshowbase -> - 
%% syntaxe : plantype str2 planshowbase -> - 
%% syntaxe : plantype planshowbase -> - 
/planshowbase {
3 dict begin
   dup isbool {
      /mybool exch def
   } {
      /mybool true def
   } ifelse
   dup isstring {
      /couleur2 exch def
      dup isstring {
         /couleur1 exch def
      } {
         /couleur1 (rouge) def
      } ifelse
   } {
      /couleur1 (rouge) def
      /couleur2 (vert) def
   } ifelse
   mybool bprojscene
      couleur1 cvx exec
      newpath
         0 0 smoveto
         1 0 slineto
      Stroke
      0 0 1 0 oldarrow
      couleur2 cvx exec
      newpath
         0 0 smoveto
         0 1 slineto
      Stroke
      0 0 0 1 oldarrow
   eprojscene
end
} def

%% syntaxe : plantype str1 str2 str3 planshowbase3d -> - 
%% syntaxe : plantype str2 str3 planshowbase3d -> - 
%% syntaxe : plantype str3 planshowbase3d -> - 
%% syntaxe : plantype planshowbase3d -> - 
%% syntaxe : plantype str1 str2 str3 array planshowbase3d -> - 
%% syntaxe : plantype str2 str3 array planshowbase3d -> - 
%% syntaxe : plantype str3 array planshowbase3d -> - 
%% syntaxe : plantype array planshowbase3d -> - 
/planshowbase3d {
7 dict begin
   dup isbool {
      /mybool exch def
   } {
      /mybool true def
   } ifelse
   dup dup isarray exch isplan not and {
      /table exch def
   } {
      /table {} def
   } ifelse
   dup isstring {
      /couleur3 exch def
      dup isstring {
         /couleur2 exch def
         dup isstring {
            /couleur1 exch def
         } {
            /couleur1 (rouge) def
         } ifelse
      } {
         /couleur2 (vert) def
         /couleur1 (rouge) def
      } ifelse
   } {
      /couleur1 (rouge) def
      /couleur2 (vert) def
      /couleur3 (bleu) def
   } ifelse
   /plan exch def
   plan couleur1 couleur2 mybool planshowbase
   plan plangetorigine /I defpoint3d
   plan plangetbase
   dup 0 getp3d /u defpoint3d
   1 getp3d /v defpoint3d
   u v vectprod3d table newvecteur
   {I addv3d} solidtransform
   dup couleur3 solidputcolors
   solidgridOff
   drawsolid**
end
} def

%% syntaxe : plantype x y z plantranslate --> -
/plantranslate {
4 dict begin
   /M defpoint3d
   /plan exch def
   plan isplan not {
      (Erreur : mauvais type d argument dans plantranslate) ==
      quit
   } if
   plan plan plangetorigine M addv3d planputorigine
end
} def

% syntaxe : alpha_x alpha_y alpha_z rotateOpplan --> -
/rotateOplan {
4 dict begin
   /Rxyz defpoint3d
   /plan exch def
   plan isplan not {
      (Erreur : mauvais type d argument dans rotateOplan) ==
      quit
   } if
   plan plan plangetorigine Rxyz rotateOpoint3d planputorigine

   plan plangetbase 0 getp3d /U defpoint3d
   plan plangetbase 1 getp3d /V defpoint3d
   plan [
      U Rxyz rotateOpoint3d
      V Rxyz rotateOpoint3d
   ] planputbase
end
} def

%% syntaxe : plantype phi rotateplan --> -
/rotateplan {
5 dict begin
   /phi exch def
   /leplan exch def
   leplan plangetbase 0 getp3d /U defpoint3d
   leplan plangetbase 1 getp3d /V defpoint3d
   U phi cos mulv3d
   V phi sin mulv3d addv3d /U0 defpoint3d
   U phi sin neg mulv3d
   V phi cos mulv3d addv3d /V0 defpoint3d
   leplan [U0 V0] planputbase
end
} def

%% syntaxe : solid i solidface2plan --> plantype
%% syntaxe : solid i I solidface2plan --> plantype
/solidface2plan {
5 dict begin
   2 copy pop issolid {
      /i exch def
      /solid exch def
      solid i solidcentreface /I defpoint3d
   } {
      /I defpoint3d
      /i exch def
      /solid exch def
   } ifelse
   /result newplanaffine def
   solid i solidcentreface /G defpoint3d
   solid i solidnormaleface /K defpoint3d
   solid 0 i solidgetsommetface
   solid 1 i solidgetsommetface
   milieu3d /A defpoint3d
   G A vecteur3d normalize3d /U defpoint3d
   K U vectprod3d /V defpoint3d
   result [U V] planputbase
   result I planputorigine
   result
end
} def

%%%%% ### fin insertion ###
%% syntaxe : x y plantype pointplan --> X Y Z
/pointplan {
5 dict begin
   /leplan exch def
   /y exch def
   /x exch def
   leplan plangetbase 0 getp3d /U defpoint3d
   leplan plangetbase 1 getp3d /V defpoint3d
   U x mulv3d V y mulv3d addv3d
end
} def

%%%%% ### fin insertion ###


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%     operations sur des solides particuliers        %%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

/piedist {
4 dict begin
   /mypie exch def
   mypie 0 solidgetface length /n exch def
   mypie n 2 idiv solidgetsommet /A defpoint3d
   mypie n 2 idiv 1 add solidgetsommet /B defpoint3d
   A B milieu3d GetCamPos distance3d
end
} def

/sortpieset {
5 dict begin
   dup issolid {
      ]
   } if
   /table exch def
   [
      0 1 table length 1 sub {
         /i exch def
         table i get piedist
      } for
   ]
   doublequicksort pop reverse
   /result exch def
   [
      0 1 result length 1 sub {
         /i exch def
         table result i get get 
      } for
   ]
end
} def

/drawpieset {
1 dict begin
   /startest true def
   sortpieset dup {drawsolid**} apply {0 dessinefacevisible} apply
end
} def

%%%%% ### solidchanfreine ###
%% syntaxe : solid coeff solidchanfreine --> solid
/solidchanfreine {
10 dict begin
   /coeff exch def
   /solid exch def
   /result newsolid def
   solid issolid not {
      (Erreur : mauvais type d argument dans solidchanfreine) ==
      quit
   } if
   /n solid solidnombresommets def
   /nf solid solidnombrefaces def

   %% ajout des faces reduites
   0 1 nf 1 sub {
      /i exch def
      /Fsommets solid i solidgetsommetsface def
      /Findex solid i solidgetface def
      /ns Fsommets length 3 idiv def
      /couleurfaceorigine solid i solidgetfcolor def
      Fsommets isobarycentre3d /G defpoint3d
      %% on ajoute les nouveaux sommets
      /Sindex [] def
      0 1 ns 1 sub {
         /j exch def
         /Sindex [ Sindex aload pop
            Fsommets j getp3d /M defpoint3d
            result M G coeff hompoint3d solidaddsommet
         ] store
      } for
      %% Sindex contient les indices des nouveaux sommets
      result Sindex couleurfaceorigine solidaddface
   } for

   %% ajout des faces rectangulaires entre faces d'origines adjacentes
   %% pour chaque face de depart
   0 1 nf 2 sub {
      /i exch def
      /F solid i solidgetface def
      /couleurfaceorigine solid i solidgetfcolor def
      /Fres result i solidgetface def
      %% pour chaque arete de la face
      0 1 F length 1 sub {
         /j exch def
         /trouve false def
         /indice1 F j get def
         /indice2 F j 1 add F length mod get def
         /a1 j def
         /a2 j 1  add F length mod def
         %% on regarde toutes les autres faces
         i 1 add 1 nf 1 sub {
            /k exch def
            /Ftest solid k solidgetface def
            indice1 Ftest in {pop true} {false} ifelse
            indice2 Ftest in {pop true} {false} ifelse
            and {
               /indiceFadj k def
               indice1 Ftest in pop /k1 exch def
               indice2 Ftest in pop /k2 exch def
               /trouve true def
            exit
            } if
         } for
         trouve {
            /Fadj solid indiceFadj solidgetface def
            result [
               Fres a1 get
               result indiceFadj solidgetface k1 get
               result indiceFadj solidgetface k2 get
               Fres a2 get
            ] couleurfaceorigine solidaddface
         } if
      } for
   } for

   %% pour chaque face
   0 1 nf 2 sub {
      /i exch def
      /F solid i solidgetface def
      /couleurfaceorigine solid i solidgetfcolor def
      %% et pour chaque sommet de cette face
      0 1 F length 1 sub {
         /j exch def
         /k F j get def
         solid k solidfacesadjsommet /adj exch def
         %% adj est le tableau des indices des faces adjacentes
         %% au sommet d'indice k
         %% rque : toutes les faces d'indice strict inferieur a i
         %% sont deja traitees
         %% Pour chaque face adjacente, on repere l'indice du sommet concerne dans
         %% la face
         adj min i lt not {
            /indadj [] def
            0 1 adj length 1 sub {
               /m exch def
               k solid adj m get solidgetface in {
                  /ok exch def
                  /indadj [indadj aload pop ok] store
               } if
            } for
         
            /aajouter [
               0 1 adj length 1 sub {
                  /m exch def
                  result adj m get solidgetface indadj m get get
               } for
            ] def

            %% la table des sommets
            [0 1 aajouter length 1 sub {
               /m exch def
               result aajouter m get solidgetsommet
            } for]
            solid k solidgetsommet %% le point indiquant la direction de la normale
            ordonnepoints3d
            /indicestries exch def

            result [
               0 1 indicestries length 1 sub {
                  /m exch def
                  aajouter indicestries m get get
               } for
            ] couleurfaceorigine solidaddface
         } if
      } for
   } for

   result
end
} def

%%%%% ### solidplansection ###
%% syntaxe : M eqplan --> real
%% image de M par la fonction definie par l equation eqplan
/pointeqplan {
8 dict begin
   /@qplan exch def
   /@z exch def
   /@y exch def
   /@x exch def
   /@a @qplan 0 get def
   /@b @qplan 1 get def
   /@c @qplan 2 get def
   /@d @qplan 3 get def
   @a @x mul @b @y mul add @c @z mul add @d add 
end
} def

%% syntaxe : A B eqplan segment_inter_plan --> array true ou false
%% array contient 1 point M si [AB] inter plan = {M}
%% array contient les 2 points A et B si [AB] inter plan = [AB]
/segment_inter_plan {
4 dict begin
   dup isplan {plan2eq} if
   /plan exch def
   plan aload pop
   /d exch def
   /c exch def
   /b exch def
   /a exch def
   /B defpoint3d
   /A defpoint3d
   A 
   /zA exch def
   /yA exch def
   /xA exch def
   B 
   /zB exch def
   /yB exch def
   /xB exch def
   /imA a xA mul b yA mul add c zA mul add d add def
   /imB a xB mul b yB mul add c zB mul add d add def
   imA imB mul dup 0 gt {
      %% pas d intersection
      pop
      false
   } {
      0 eq {
         %% intersection en A ou en B
         [ 
            imA 0 eq {A} if 
            imB 0 eq {B} if 
         ] true
      } {
         %% intersection entre A et B
         /k 
            imA neg
            xB xA sub a mul
            yB yA sub b mul add
            zB zA sub c mul add
            dup 0 eq {
               (Error dans segment_inter_plan) ==
               quit
            } if
            div
         def
         [
            A B vecteur3d
            k mulv3d
            A addv3d
         ] true
      } ifelse
   } ifelse
end
} def

%% syntaxe : solid i solidface2eqplan --> [a b c d]
%% equation cartesienne de la face d'indice i du solide solid
/solidface2eqplan {
8 dict begin
   /i exch def
   /solid exch def
   solid i solidnormaleface
   /c exch def
   /b exch def
   /a exch def
   solid 0 i solidgetsommetface
   /z exch def
   /y exch def
   /x exch def
   [a b c a x mul b y mul add c z mul add neg]
end
} def

%% syntaxe : array1 arrayrmdouble --> array2
%% remplace 2 elts identiques consecutifs par 1 elt
/arrayrmdouble {
5 dict begin
   /table exch def
   /result [table 0 get] def
   /j 0 def
   1 1 table length 1 sub {
      /i exch def
      table i get
      result j get
      eq not {
         /result [result aload pop table i get] store
         /j j 1 add store
      } if
   } for
   result
end
} def

%% syntaxe : solid eqplan/plantype solidplansection --> solid2
/solidplansection {
10 dict begin
   dup isbool {
      /tr@nsmit exch def
   } {
      /tr@nsmit false def
   } ifelse
   dup isplan {
      plan2eqplan
      /eqplan exch def
   } {
      /eqplan exch def
   } ifelse
   dupsolid /result exch def
   /solid exch def
   /aenlever [] def
   /indnouveauxsommets [] def
   /nouvellesaretes [] def

   %% pour chaque face d'indice i
   0 1 solid solidnombrefaces 1 sub {
      /i exch def
      /lacouleur solid i solidgetfcolor def
      /F solid i solidgetface def %% table des indices des sommets
      /n F length def %% nb d'aretes
      /k1 -1 def
      /k2 -1 def
      /k3 -1 def
      /k4 -1 def
      /k3a -3 def
      /k4a -3 def
      %% pour chaque arete [AB]
      0 1 n 1 sub {
         /j exch def
         %% arete testee : [j, j+1 mod n] (indices relatifs a la face i)
         solid j i solidgetsommetface /A defpoint3d
         solid j 1 add n mod i solidgetsommetface /B defpoint3d
         %% y a-t-il intersection
         A B eqplan segment_inter_plan {
            %% il y a intersection
            dup length 6 eq {
               %% l'intersection, c'est [AB]
               /k1 -1 def
               /k2 -1 def
               /k3 -1 def
               /k4 -1 def
               /k3a -1 def
               /k4a -1 def
               dup 0 getp3d /A defpoint3d
               1 getp3d /B defpoint3d
               result A solidaddsommet /a1 exch def
               result B solidaddsommet /a2 exch def
               /indnouveauxsommets [
                  indnouveauxsommets aload pop a1 a2
               ] store
               /nouvellesaretes [
                  [a1 a2]
                  nouvellesaretes aload pop
               ] store
               exit %% c est deja scinde
            } if
            %% il y a intersection <> [AB]
            k1 0 lt {
            %% 1ere intersection de la face
               /k1 j def %% sommet precedent intersection 1
               result exch aload pop solidaddsommet
               /k1a exch def %% sommet intersection 1
            } {
               k2 0 lt {
               %% 2eme intersection de la face
                  /k2 j def %% sommet precedent intersection 2
                  result exch aload pop solidaddsommet
                  /k2a exch def %% sommet intersection 2
               } {
                  k3 0 lt {
                  %% 3eme intersection de la face
                     /k3 j def %% sommet precedent intersection 3
                     result exch aload pop solidaddsommet
                     /k3a exch def %% sommet intersection 3
                  } {
                  %% 4eme intersection de la face
                     /k4 j def %% sommet precedent intersection 4
                     result exch aload pop solidaddsommet
                     /k4a exch def %% sommet intersection 4
                  } ifelse
               } ifelse
            } ifelse
         } if
      } for
      
      %% y a-t-il eu une coupe ?
      %% si oui, il faut scinder la face d'indice i en cours 
      k1 0 ge {
%% (coupe) ==
%% (n) == n ==
%% k1 == k2 == k3 == k4 ==
%% (a) ==
%% k1a == k2a == k3a == k4a ==
         k1a k2a eq k3 0 lt and {
            %% 1 pt d'intersection
         } {
            %% il y a coupe, on cherche a eliminer les
            %% doublons dans {k1a, k2a, k3a, k4a}
            k1a k2a eq k3 0 ge and {
               %% 2 pts d'intersection
               /k2a k3a def
               /k2 k3 def
            } if
            k1a k3a eq k4 0 ge and {
               %% 2 pts d'intersection
               /k2a k4a def
               /k2 k4 def
            } if
            /nouvellesaretes [
               [k1a k2a]
               nouvellesaretes aload pop
            ] store
            [
               k1a F k1 1 add n mod get ne {
                  k1a
               } if
               k1 1 add n mod 1 k2 {F exch get} for
               k2a F k2 get ne {
                  k2a
               } if
            ]
            result exch lacouleur solidaddface
            /indnouveauxsommets [indnouveauxsommets aload pop k1a k2a] store
            [
               k2a F k2 1 add n mod get ne {
                  k2a
               } if
               k2 1 add n ne {
                  k2 1 add n mod 1 n 1 sub {F exch get} for
               } if
               0 1 k1 {F exch get} for
               k1a F k1 get ne {
                  k1a
               } if
            ]
            result exch lacouleur solidaddface
            /aenlever [aenlever aload pop i] store
         } ifelse
      } if
   } for
   result aenlever solidrmfaces

   nouvellesaretes separe_composantes
   /composantes exch def

   %% pour chacune des composantes
   0 1 composantes length 1 sub {
      %% on oriente et on ajoute la face
      /icomp exch def
      %indnouveauxsommets bubblesort arrayrmdouble
      /indnouveauxsommets composantes icomp get def
      %% maintenant, on ajoute la face de plan de coupe
      /nouveauxsommets [
         0 1 indnouveauxsommets length 1 sub {
            /i exch def
            result indnouveauxsommets i get solidgetsommet
         } for
      ] def
   
      0 0 0 eqplan pointeqplan 0 eq {
         /ptref {0 1 1} def
      } {
         /ptref {0 0 0} def
      } ifelse
   
      %% restera a traiter le cas limite ou la nouvelle face existe deja
      %% tester si max(indicestries) < nb sommets avant section
      nouveauxsommets ptref ordonnepoints3d
      /indicestries exch def
      /nvelleface [
         0 1 indicestries length 1 sub {
            /m exch def
            indnouveauxsommets indicestries m get get
         } for
      ] def
      /F result solidgetfaces def
      /FC result solidgetfcolors def
      /IO result solidgetinouttable def
      /n1 IO 1 get def
      IO 1 n1 1 add put
      result IO solidputinouttable
      result [nvelleface F aload pop] solidputfaces
      result [lacouleur FC aload pop] solidputfcolors
   } for
   result
   tr@nsmit {
      composantes length 
   } if
end    
} def

%% syntaxe : elt array compteoccurences
%% ou array est un tableau du type [ [a1 a2] [b1 b2] [c1 c2] ... ]
/compteoccurences {
5 dict begin
   /table exch def
   /elt exch def
   /n 0 def
   0 1 table length 1 sub {
      /i exch def
      elt table i get in {
         pop
         /n n 1 add store
      } if
   } for
   n
end
} def

/separe_composantes {
10 dict begin
   /result [] def %% les composantes deja faites
   /table exch def %% ce qui reste a faire

%   (recu) == table {==} apply
   {
      /ext1 table 0 get 1 get def
      /ext0 table 0 get 0 get def
      /composante [] def
   
      { %% maintenant on suit les extremites et on epluche une composante
         /change false def
         /aenlever [] def
         0 1 table length 1 sub {
            /i exch def
            ext1 table i get In
            ext0 table i get In or {
               /aenlever [aenlever aload pop i] store
               /change true store
               %% l'arete i contient l'extremite ext0 ou ext1
               ext0 table i get in {
                  %% index = 0 ou 1
                  neg 1 add table i get exch get
                  /ext0 exch store
                  ext0 composante In not {
                     /composante [composante aload pop ext0] store
                  } if
                  %% on verifie que ext0 est legitime
                  ext0 table compteoccurences 2 gt {
                     /ext0 -1 store
                  } if
               } if
               ext1 table i get in {
                  %% index = 0 ou 1
                  neg 1 add table i get exch get
                  /ext1 exch store
                  ext1 composante In not {
                     /composante [composante aload pop ext1] store
                  } if
                  %% on verifie que ext1 est legitime
                  ext1 table compteoccurences 2 gt {
                     /ext1 -1 store
                  } if
               } if
            } if
         } for
         %% il faut reconstruire table
         /table [
            0 1 table length 1 sub {
               /i exch def
               i aenlever in {
                  pop
               } {
                  table i get
               } ifelse
            } for
         ] store
         change not {exit} if
      } loop
      %% on vient de finir une composante
      /result [result aload pop composante] store
      %% (nouvelle comp) == composante {==} apply
      table length 0 eq {exit} if
   } loop
   result
%   (renvoie) == result {==} apply
end
} def

/solideqplansepare {solidplansepare} def
    
%% syntaxe : solid eqplan/plantype solidplansepare --> solid1 solid2
/solidplansepare {
10 dict begin
   dup isplan {
      plan2eq
      /eqplan exch def
   } {
      /eqplan exch def
   } ifelse
   eqplan true solidplansection
   /nbcomposantes exch def
   /solid exch def
   /n solid solidnombrefaces def

   /F [] def
   /FC [] def
   %% on retire les faces de coupe
   0 1 nbcomposantes 1 sub {
      /i exch def
      /F [F aload pop solid i solidgetface] store
      /FC [FC aload pop solid i solidgetfcolor] store
   } for
   solid [0 1 nbcomposantes 1 sub {} for] solidrmfaces
   /n n nbcomposantes sub store

   %% on separe les autres faces en 2 parties
   /lesneg [] def %% indices des faces "positives"
   /lespos [] def %% indices des faces negatives"
   0 1 n 1 sub {
      /i exch def
      solid i solidcentreface /G defpoint3d
      G eqplan pointeqplan dup 0 gt {
         pop
         /lespos [lespos aload pop i] store
      } {
         0 lt {
            /lesneg [lesneg aload pop i] store
         } {
%           /lesneg [lesneg aload pop i] store
%           /lespos [lespos aload pop i] store
         } ifelse
      } ifelse
   } for
   solid
   dupsolid dup lesneg solidrmfaces
   /result1 exch def
   dupsolid dup lespos solidrmfaces
   /result2 exch def
   pop

   0 1 nbcomposantes 1 sub {
      /i exch def
      /facecoupe F i get def
      /couleurfacecoupe FC i get def
      /lesfaces1 result1 solidgetfaces def
      /lescouleurs1 result1 solidgetfcolors def
      /IO1 result1 solidgetinouttable def
      /lesfaces2 result2 solidgetfaces def
      /lescouleurs2 result2 solidgetfcolors def
      /IO2 result2 solidgetinouttable def
      %% on rajoute maintenant la face du plan de coupe
%      result1 facecoupe couleurfacecoupe solidaddface
      result1 [facecoupe lesfaces1 aload pop] solidputfaces
      result1 [couleurfacecoupe lescouleurs1 aload pop] solidputfcolors
      result1 IO1 dup dup 1 get 1 add 1 exch put solidputinouttable
      %% et on verifie l'orientation
%      result1 dup solidnombrefaces 1 sub solidnormaleface 
%      result1 dup solidnombrefaces 1 sub solidcentreface addv3d
      result1 0 solidnormaleface 
      result1 0 solidcentreface addv3d
      eqplan pointeqplan 0 gt {
         %% l'orientation est mauvaise
         result1 0 solidrmface 
         result2 [facecoupe lesfaces2 aload pop] solidputfaces
         result2 [couleurfacecoupe lescouleurs2 aload pop] solidputfcolors
         result2 IO2 dup dup 1 get 1 add 1 exch put solidputinouttable
         result1 [facecoupe reverse lesfaces1 aload pop] solidputfaces
         result1 [couleurfacecoupe lescouleurs1 aload pop] solidputfcolors
         result1 dup solidgetinouttable dup dup 1 get 1 add 1 exch put solidputinouttable
      } {
         %% l'orientation est ok
         result2 IO2 dup dup 1 get 1 add 1 exch put solidputinouttable
         result2 [facecoupe reverse lesfaces2 aload pop] solidputfaces
         result2 [couleurfacecoupe lescouleurs2 aload pop] solidputfcolors
      } ifelse
   } for
   
   %% maintenant on enleve les sommets isoles
   /sommetspos [] def
   /sommetsneg [] def
   %% pour chaque face du cote negatif
   0 1 lesneg length 1 sub {
      lesneg exch get /i exch def
      /F solid i solidgetface def
      %% pour chaque sommet de cette face
      0 1 F length 1 sub {
         /j exch def
         /sommet F j get def
         %% si le sommet n'est pas encore note
         sommet sommetsneg in not {
            %% et s'il est isole, on peut l'enlever
            result1 sommet solidsommetsadjsommet length 0 eq {
               /sommetsneg [sommetsneg aload pop sommet] store
            } if
         } {
            pop
         } ifelse
      } for
   } for
   sommetsneg bubblesort reverse {result1 exch solidrmsommet} apply

   %% pour chaque face du cote positif
   0 1 lespos length 1 sub {
      lespos exch get /i exch def
      /F solid i solidgetface def
      %% pour chaque sommet de cette face
      0 1 F length 1 sub {
         /j exch def
         /sommet F j get def
         %% si le sommet n'est pas encore note
         sommet sommetspos in not {
            %% et s'il est isole, on peut l'enlever
            result2 sommet solidsommetsadjsommet length 0 eq {
               /sommetspos [sommetspos aload pop sommet] store
            } if
         } {
            pop
         } ifelse
      } for
   } for
   sommetspos bubblesort reverse {result2 exch solidrmsommet} apply

   result1 result2
end
} def

%%%%% ### solidaffine ###
%% syntaxe : solid coeff i solidaffine -> -
%% syntaxe : solid coeff array solidaffine -> -
%% syntaxe : solid coeff solidaffine -> -
%% syntaxe : solid coeff str solidaffine -> -
%% syntaxe : solid coeff bool solidaffine -> -
/solidaffine {
10 dict begin
   dup isbool {
      /rmfacecentrale exch def
   } {
      /rmfacecentrale true def
   } ifelse
   dup isstring {
      /couleurface exch def
   } if
   2 copy pop issolid {
      %% 2 arguments --> on affine tout
      2 copy pop solidnombrefaces /n exch def
      /table [n 1 sub -1 0 {} for] def 
   } {
      %% 1 tableau --> il donne les faces a enlever
      dup isarray {
         /table exch bubblesort reverse def
      } {
      %% 1 seule face a enlever
         [ exch ] /table exch def
      } ifelse
   } ifelse
   /coeff exch def
   /solid exch def
   0 1 table length 1 sub {
      /i exch def
      solid coeff table i get 
      currentdict /couleurface known {
         couleurface 
      } if
      rmfacecentrale s@lidaffineface
   } for
end
} def

%% syntaxe : solid coeff i s@lidaffineface
 /s@lidaffineface {
10 dict begin
   /rmfacecentrale exch def
   dup isstring {
      /couleurface exch def
   } if
   /indice_a_chamfreiner exch def
   /i indice_a_chamfreiner def
   /coeff exch def
   /solid exch def
   solid issolid not {
      (Erreur : mauvais type d argument dans affine) ==
      quit
   } if
   /n solid solidnombresommets def
   /F solid i solidgetsommetsface def
   /Findex solid i solidgetface def
   /ni F length 3 idiv def
   /couleurfaceorigine solid i solidgetfcolor def
   F isobarycentre3d /G defpoint3d
   %% on ajoute les nouveaux sommets
   /Sindex [] def
   0 1 ni 1 sub {
      /j exch def
      /Sindex [ Sindex aload pop
         solid G F j getp3d vecteur3d coeff mulv3d G addv3d solidaddsommet
      ] store
   } for
   %% Sindex contient les indices des nouveaux sommets
   %% on prepare les faces a ajouter
   /facestoadd [] def
   /facestoadd [facestoadd aload pop
   0 1 ni 1 sub {
      /j exch def
      [Findex j get
      Findex j 1 add ni mod get
      Sindex j 1 add ni mod get
      Sindex j get]
   } for
   ] store
   0 1 ni 1 sub {
      /i exch def
      solid facestoadd i get solidaddface
   } for
   %% on enleve la face d origine
   solid indice_a_chamfreiner solidrmface
   %% on ajuste les couleurs des nouvelles faces
   /N solid solidnombrefaces def
   0 1 ni 1 sub {
      /i exch def
      solid N 1 sub i sub couleurfaceorigine solidputfcolor
   } for
   %% puis on ajoute eventuellement la face centrale
   rmfacecentrale not {
      solid
      [0 1 ni 1 sub {
         /j exch def
         Sindex j get
      } for]
      solidaddface
      %% en ajustant la couleur de cette derniere
      solid N
      currentdict /couleurface known {
            couleurface 
      } {
         couleurfaceorigine
      } ifelse
      solidputfcolor
   } if
end
} def

%%%%% ### solidtronque ###
%% syntaxe : solid indicesommet k solidtronque --> solid
%% syntaxe : solid array k solidtronque --> solid
%% syntaxe : solid k solidtronque --> solid
%% k entier > 0, array = tableau des indices des sommets
/solidtronque {
10 dict begin
   /coeff exch def
   dup issolid {
      dup solidnombresommets /N exch def
      /table [0 1 N 1 sub {} for] def
   } {
      dup isarray {
         /table exch def
      } {
         [ exch ] /table exch def
      } ifelse
   } ifelse
   /solid exch def
   solid dupsolid /result exch def pop
   /n solid solidnombrefaces def
   0 1 table length 1 sub {
      table exch get /no exch def
      result no solidgetsommet /sommetvise defpoint3d
      %% on recup les sommets adjacents au sommet vise
      /sommetsadj solid no solidsommetsadjsommet def
      %% on calcule les nouveaux sommets
      /nouveauxsommets [
         0 1 sommetsadj length 1 sub {
            /i exch def
            solid sommetsadj i get solidgetsommet
         } for
      ] {sommetvise exchp3d coeff ABpoint3d} papply3d def 
      %% on pose G = barycentre de ces points
      nouveauxsommets isobarycentre3d /G defpoint3d
      %% il faut ordonner ces sommets
      nouveauxsommets 0 getp3d /ptref defpoint3d
      G result no solidgetsommet vecteur3d /vecteurnormal defpoint3d
      %% on construit le tableau des angles ordonnes par rapport
      %% a la normale
      nouveauxsommets duparray exch pop
      {1 dict begin
         /M defpoint3d
         G ptref vecteur3d
         G M vecteur3d
         vecteurnormal angle3doriente
      end} papply3d
      doublebubblesort pop
      %% nos sommets sont tries
      /indicesommetstries exch def
      %% on rajoute les sommets au solide, et on note les nouveaux indices
      /nouveauxindices [
         0 1 nouveauxsommets length 3 idiv 1 sub {
            /k exch def
            result nouveauxsommets k getp3d solidaddsommet
         } for
      ] def
      %% on ajoute la face concernee
      result [
         0 1 indicesommetstries length 1 sub {
            /k exch def
         nouveauxindices indicesommetstries k get get
         } for 
      ] solidaddface
      result no solidfacesadjsommet /lesfaces exch def
      %% on examine la face d indice i, et on elimine le
      %% sommet vise
      0 1 lesfaces length 1 sub {
         /i exch def
         /j lesfaces i get def
         /F result j solidgetface def 
         result [
            0 1 F length 1 sub {
               /k exch def 
               F k get dup no eq {pop} if
            } for
         ] j exch solidputface 
      } for
   } for
   table bubblesort reverse {result exch solidrmsommet} apply
   result
end
} def

%%%%% ### dualpolyedre ###
%% syntaxe : solid dualpolyedreregulier --> solid
%% syntaxe : solid r dualpolyedreregulier --> solid
%% si le nombre r est present, projette les nouveaux sommets sur la sphere de centre O , de rayon r
/dualpolyedreregulier {
20 dict begin
   dup isnum {
      /r exch def
      /projection true def
   } {
      /projection false def
   } ifelse
   /solid exch def
   solid dupsolid /result exch def pop
   /n solid solidnombrefaces def
   /N solid solidnombresommets def
   /facesaenlever [] def
   %% pour chacun des sommets
   0 1 N 1 sub {
      %% sommet d indice i
      /i exch def
      %% indicesfacesadj = liste des indices des faces ou on trouve le sommet i
      /indicesfacesadj solid i solidfacesadjsommet def
      %% on recupere les centres des faces concernees
      /nouveauxsommets [
         0 1 indicesfacesadj length 1 sub {
            /k exch def 
            solid indicesfacesadj k get solidgetsommetsface isobarycentre3d
         } for
      ] def
      %% et on pose G = barycentre de ces points
      nouveauxsommets isobarycentre3d /G defpoint3d
      %% il faut ordonner ces sommets
      nouveauxsommets 0 getp3d /ptref defpoint3d
      G solid i solidgetsommet vecteur3d /vecteurnormal defpoint3d
      nouveauxsommets duparray exch pop
      {1 dict begin
         /M defpoint3d
         G ptref vecteur3d
         G M vecteur3d
         vecteurnormal angle3doriente
      end} papply3d
      doublebubblesort pop
      %% nos sommets sont tries
      /indicesommetstries exch def
      projection {
         %% on projette les sommets sur la sphere
         /nouveauxsommets [ nouveauxsommets {normalize3d r mulv3d} papply3d aload pop ] store
      } if
      %% puis on les rajoute au solide
      /nouveauxindices [
         0 1 nouveauxsommets length 3 idiv 1 sub {
            /k exch def
            result nouveauxsommets k getp3d solidaddsommet
         } for
      ] def
      %% ainsi que la face concernee
      result [
         0 1 indicesommetstries length 1 sub {
            /k exch def
         nouveauxindices indicesommetstries k get get
         } for 
      ] solidaddface
      /facesaenlever [ facesaenlever aload pop indicesfacesadj aload pop ] store
   } for
   result [0 1 n 1 sub {} for] solidrmfaces
   [N 1 sub -1 0 {} for] {result exch solidrmsommet} apply
   result
end
} def

%%%%% ### newgeode ###
%% syntaxe : solid r newgeode --> solid
%% syntaxe : N r newgeode --> solid
%% N in {3,4,5} -> polyhedre de depart, r = niveau de recursion
/newgeode {
2 dict begin
   /r exch def
   dup issolid not {
      /N exch def
      N 3 eq {
         1 newtetraedre
      } {
         N 4 eq {
            1 newoctaedre
         } {
            1 newicosaedre
         } ifelse
      } ifelse
   } if

   r {
      15 dict begin   
         /solid exch def
         solid dupsolid /result exch def pop
         /n solid solidnombrefaces def
         n 1 sub -1 0 {
            /i exch def
            %% la face d indice i
            solid i solidgetface /F exch def
            /i0 F 0 get def
            /i1 F 1 get def
            /i2 F 2 get def
            solid i0 solidgetsommet /A0 defpoint3d
            solid i1 solidgetsommet /A1 defpoint3d
            solid i2 solidgetsommet /A2 defpoint3d
            A0 A1 milieu3d normalize3d /A01 defpoint3d
            A1 A2 milieu3d normalize3d /A12 defpoint3d
            A2 A0 milieu3d normalize3d /A20 defpoint3d
            result A01 solidaddsommet /i01 exch def
            result A12 solidaddsommet /i12 exch def
            result A20 solidaddsommet /i20 exch def
            result i solidrmface
            result [i0 i01 i20] solidaddface
            result [i01 i1 i12] solidaddface
            result [i01 i12 i20] solidaddface
            result [i20 i12 i2] solidaddface
         } for
         result
      end
   } repeat
end
} def

%% syntaxe : N r newdualgeode --> solid
/newdualgeode {
   newgeode 1
   dualpolyedreregulier
} def

%%%%% ### fin insertion ###


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%             quelques solides precalcules           %%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%%%%% ### newface ### 
%% syntaxe : array newmonoface -> solid
%% ou array = tableau de points 2d
/newmonoface {
4 dict begin
   /table exch def
   /n table length 2 idiv def
   /S table {0} papply def

   /F [
       [0 1 n 1 sub {} for]
   ] def
   S F generesolid
end
} def

%% syntaxe : array newbiface -> solid
%% ou array = tableau de points 2d
/newbiface {
   newmonoface
   dup videsolid
} def

%%%%% ### newpolreg ### 
%% syntaxe : r n newpolreg --> solid
/newpolreg {
5 dict begin
   /n exch def
   /r exch def
   /S [
       0 360 n div 360 360 n div sub {
           /theta exch def
           theta cos r mul
           theta sin r mul
           0
       } for
   ] def
   /F [
       [0 1 n 1 sub {} for]
   ] def

   S F generesolid
   dup videsolid
end
} def

%%%%% ### newgrille ### 
%% syntaxe : xmin xmax ymin ymax [dx dy] newgrille -> solid
%% syntaxe : xmin xmax ymin ymax [nx ny] newgrille -> solid
%% syntaxe : xmin xmax ymin ymax {mode} newgrille -> solid
%% syntaxe : xmin xmax ymin ymax newgrille -> solid
/newgrille {
10 dict begin
   [[/nx /ny] [1 1] [1. 1.] [1. 1.] [1. 1.] [.5 .5]] gestionsolidmode
   %% ny nb d etages en y
   %% nx nb d etages en x
   /biface false def
   [nx ny] {0} newsurfaceparametree
end
} def

%% %% syntaxe : xmin xmax ymin ymax [dx dy] {f} newsurface -> solid
%% %% f : R^2 -> R
/newsurface {
   true newsurfaceparametree
} def

/biface true def

/newsurfaceparametree {
10 dict begin
   dup isbool {
      pop /surfz true def
   } {
      /surfz false def
   } ifelse
   /f_surface exch def
   [[/nx /ny] [2 2] [4 4] [1. 1.] [1. 1.] [.25 .25]] gestionsolidmode
   %% ny nb d etages en y
   %% nx nb d etages en x
   /ymax exch def
   /ymin exch def
   /xmax exch def
   /xmin exch def

   nx isinteger not {
       %% alors nx est un dx
       /nx xmax xmin sub nx div cvi store
   } if
   ny isinteger not {
       %% alors ny est un dy
       /ny ymax ymin sub ny div cvi store
   } if
   /dy ymax ymin sub ny div def %% le pas sur y
   /dx xmax xmin sub nx div def %% le pas sur x

   /S [
       0 1 nx {
           /i exch def
           0 1 ny {
               /j exch def
               /u xmin i dx mul add def
               /v ymin j dy mul add def
               u v
               surfz {2 copy} if
               f_surface
               pstrickactionR3
           } for
       } for
   ] def

   /F [
       0 1 nx 1 sub {
          /i exch def
          0 1 ny 1 sub {
             /j exch def
             [
                j 1 add        i ny 1 add mul add
                j              i ny 1 add mul add
                j ny 1 add add i ny 1 add mul add
                j ny 2 add add i ny 1 add mul add
             ]
          } for
       } for
%%       0 1 0 {%nx 1 sub {
%%          /i exch def
%%          0 1 0 {%ny 2 sub {
%%             /j exch def
%%             [
%%             j 1 add        %% i ny mul add
%%             j              %% i ny mul add
%%             ny 1 add j add       %% i ny mul add
%%             ny 2 add j add     %% i ny mul add
%%             ]
%%          } for
%%       } for
   ] def
   S F generesolid
   biface pl@n-en-cours not and {dup videsolid} if
end
} def

%%%%% ### newgrillecirculaire ### 
%% syntaxe : r option newgrillecirculaire -> solid
/newgrillecirculaire {
6 dict begin
   [[/K /N] [6 6] [6 8] [10 8] [16 12] [16 36]] gestionsolidmode

   %% N = nb de meridiens (diviseur de 360 = 2^4 * 3^2 * 5)
   %% K = nb d horizontales (diviseur de 160 = 2^5 * 5)

   /r exch def
   /F [
       %% 1er etage
       1 1 N {
           /i exch def
           [0 i i N mod 1 add]
       } for
       %% etages suivants
       0 1 K 2 sub {
           /j exch def
           1 1 N {
               /i exch def
               [i      j N mul add
               i N add j N mul add
               i N mod N add 1 add j N mul add
               i N mod 1 add j N mul add]
           } for
      } for
   ] def

   %% tableau des sommets
   /S [
       0 0 0
       1 1 K {
           /j exch def
           1 1 N {
             /i exch def
             /theta i 360 mul N div def
             theta cos r j mul K div mul
             theta sin r j mul K div mul
             0 %2 copy f %exch atan 90 div
          } for
       } for
   ] def

   S F generesolid
end
} def

%% syntaxe : r [dx dy] {f} newsurface* -> solid
/newsurface* {
7 dict begin
   /f_surface exch def
   [[/nx /ny] [6 6] [6 8] [10 8] [16 12] [16 36]] gestionsolidmode

   nx isinteger not {
       %% alors nx est un dx
       /nx xmax xmin sub nx div cvi store
   } if
   ny isinteger not {
       %% alors ny est un dy
       /ny ymax ymin sub ny div cvi store
   } if
   /dy ymax ymin sub ny div def %% le pas sur y
   /dx xmax xmin sub nx div def %% le pas sur x

   %% ny = nb de meridiens
   %% nx = nb d horizontales

   /r exch def
   /F [
       %% 1er etage
       1 1 ny {
           /i exch def
           [0 i i ny mod 1 add]
       } for
       %% etages suivants
       0 1 nx 2 sub {
           /j exch def
           1 1 ny {
               /i exch def
               [i      j ny mul add
               i ny add j ny mul add
               i ny mod ny add 1 add j ny mul add
               i ny mod 1 add j ny mul add]
           } for
      } for
   ] def

   %% tableau des sommets
   /S [
       0 0 0
       1 1 nx {
           /j exch def
           1 1 ny {
             /i exch def
             /theta i 360 mul ny div def
             theta cos r j mul nx div mul
             theta sin r j mul nx div mul
             2 copy f_surface
          } for
       } for
   ] def

   S F generesolid
end
} def

%%%%% ### newruban ### 
%% syntaxe : array h u [n] newruban -> solid d axe (O, u), de maillage vertical n
%% syntaxe : array h u newruban -> solid d axe (O, u),
%% syntaxe : array h newruban -> solid d axe (O, k),
%% ou array tableau de points 2d
/newruban {
7 dict begin
   %% N = nb d etages
   [[/N] [1] [1] [1] [3] [4]] gestionsolidmode
   2 copy pop isarray {
      /u {0 0 1} def
   } {
      /u defpoint3d
   } ifelse
   u 0 eq {
      (Error : 3eme composante nulle dans le vecteur pour newruban) ==
      quit
   } if
   pop pop
   /h exch def
   /table exch def
   %% n = indice du dernier point
   /n table length 2 idiv 1 sub def
   %% vecteur de translation
   u
   h u norme3d div
   mulv3d /v defpoint3d

   %% tableau des sommets
   /S [
      0 1 N {
         /j exch def
         0 1 n {
             /i exch def
             table i getp
             0
             v N j sub N div mulv addv3d
         } for
      } for
   ] def

   /F [
      %% faces etage
      1 1 N {
         /j exch def
         1 1 n {
             /i exch def
             [i                   j 1 sub n 1 add mul add
              i 1 sub             j 1 sub n 1 add mul add
              n 1 add i add 1 sub j 1 sub n 1 add mul add
              n 1 add i add       j 1 sub n 1 add mul add]
         } for
     } for
   ] def

   S F generesolid
   dup videsolid
end
} def

%%%%% ### newicosaedre ### 
/newicosaedre {
3 dict begin
   /a exch def
   /S [
      0.8944271  0              0.4472137
      0.2763932  0.8506507      0.4472137
      -0.7236067 0.5257311      0.4472137
      -0.7236067 -0.5257311     0.4472137
      0.2763932  -0.8506507     0.4472137
      0          0              1
      0          0              -1
      -0.8944271 0              -0.4472137
      -0.2763932 -0.8506507     -0.4472137
      0.7236067  -0.5257311     -0.4472137
      0.7236067  0.5257311      -0.4472137
      -0.2763932 0.8506507      -0.4472137
   ] {a mulv3d} papply3d def

   /F [
      [0 1 5]   %% 1  2 6  ]
      [1 2 5]   %% 2  3 6  ]
      [2 3 5]   %% 3  4 6  ]
      [3 4 5]   %% 4  5 6  ]
      [4 0 5]   %% 5  1 6  ]
      [9 0 4]   %% 10 1 5  ]
      [0 9 10]  %% 1  10 11]
      [10 1 0]  %% 11 2 1  ]
      [1 10 11] %% 2  11 12]
      [11 2 1]  %% 12 3 2  ]
      [2 11 7]  %% 3  12 8 ]
      [2 7 3]   %% 3  8 4  ]
      [3 7 8]   %% 4  8 9  ]
      [3 8 4]   %% 4  9 5  ]
      [4 8 9]   %% 5  9 10 ]
      [6 7 11]  %% 7  8 12 ]
      [6 8 7]   %% 7  9 8  ]
      [6 9 8]   %% 7  10 9 ]
      [6 10 9]  %% 7  11 10]
      [6 11 10] %% 7  12 11]
   ] def

   S F generesolid
end
} def

%%%%% ### newdodecaedre ### 
/newdodecaedre {
3 dict begin
   /a exch def
   /S [
      0          0.607062   0.7946545
      -0.5773503 0.1875925  0.7946545
      -0.3568221 -0.4911235 0.7946545
      0.3568221  -0.4911235 0.7946545
      0.5773503  0.1875925  0.7946545
      0          0.982247   0.1875925
      -0.9341724 0.303531   0.1875925
      -0.5773503 -0.7946645 0.1875925
      0.5773503  -0.7946645 0.1875925
      0.9341724  0.303531   0.1875925
      0          -0.982247  -0.1875925
      0.9341724  -0.303531  -0.1875925
      0.5773503  0.7946545  -0.1875925
      -0.5773503 0.7946545  -0.1875925
      -0.9341724 -0.303531  -0.1875925
      -0.5773503 -0.1875925 -0.7946545
      -0.3568221 0.4911235  -0.7946545
      0.3568221  0.4911235  -0.7946545
      0.5773503  -0.1875925 -0.7946545
      0          -0.607062  -0.7946545
   ] {a mulv3d} papply3d def

   /F [
      [0 1 2 3 4]
      [4 3 8 11 9]
      [4 9 12 5 0]
      [0 5 13 6 1]
      [1 6 14 7 2]
      [2 7 10 8 3]
      [10 19 18 11 8]
      [11 18 17 12 9]
      [12 17 16 13 5]
      [13 16 15 14 6]
      [14 15 19 10 7]
      [15 16 17 18 19]
   ] def
   S F generesolid
end
} def

%%%%% ### newoctaedre ### 
/newoctaedre {
3 dict begin
   /a exch def
   %%Sommets
   /S [
      0  0  1
      1  0  0
      0  1  0
      -1 0  0
      0  -1 0
      0  0  -1
   ] {a mulv3d} papply3d def

   /F [
      [0 4 1]
      [1 2 0]
      [0 2 3]
      [3 4 0]
      [1 5 2]
      [2 5 3]
      [3 5 4]
      [4 5 1]
   ] def

   S F generesolid
end
} def

%%%%% ### newtetraedre ### 
/newtetraedre {
3 dict begin
   /r exch def
   %%Tetraedre
   /S [
      0          0          1
      -0.4714045 -0.8164965 -1 3 div
      0.942809   0          -1 3 div
      -0.4714045 0.8164965  -1 3 div
   ] {r mulv3d} papply3d def

   /F [
      [0 1 2]
      [0 2 3]
      [0 3 1]
      [1 3 2]
   ] def

   S F generesolid
end
} def

%%%%% ### newcube ### 
/newcube {
3 dict begin
   [[/n] [1] [1] [1] [3] [4]] gestionsolidmode
   /a exch 2 div def

   n 1 le {
      /F [
     [0 1 2 3]
     [0 4 5 1]
     [1 5 6 2]
     [2 6 7 3]
     [0 3 7 4]
     [4 7 6 5]
      ] def

      %% tableau des sommets
      /S [
      1  1  1 %% 0
     -1  1  1 %% 1
     -1 -1  1 %% 2
      1 -1  1 %% 3
      1  1 -1 %% 4
     -1  1 -1 %% 5
     -1 -1 -1 %% 6
      1 -1 -1 %% 7
      ] {a mulv3d} papply3d def
      S F generesolid
   } {
      /dl 2 n div def
      /N n dup mul n add 4 mul def
      /n1 n 1 sub dup mul def %% nb sommets centre d une face

      %% tableau des sommets
      /S1 [
     0 1 n 1 sub {
        /j exch def
        0 1 n {
           /i exch def
           -1 i dl mul add
           -1 j dl mul add
        1
        } for
     } for
      ] def

      /S2 S1 {-90 0 0 rotateOpoint3d} papply3d def
      /S3 S2 {-90 0 0 rotateOpoint3d} papply3d def
      /S4 S3 {-90 0 0 rotateOpoint3d} papply3d def

      /S5 [
     1 1 n 1 sub {
        /j exch def
        1 1 n 1 sub {
           /i exch def
        1
           -1 i dl mul add
           -1 j dl mul add
        } for
     } for
      ] def

      /S6 [
     1 1 n 1 sub {
        /j exch def
        1 1 n 1 sub {
           /i exch def
           -1
           -1 i dl mul add
           -1 j dl mul add
        } for
     } for
      ] def

      %% tableau des faces
      /F1 [
     0 1 n 1 sub {
        /j exch def
        0 1 n 1 sub {
           /i exch def
           [
          i n 1 add j mul add
          dup 1 add
          dup n 1 add add
          dup 1 sub
           ]
        } for
     } for
      ] def

      %% syntaxe : i sommettourgauche --> l indice du i-eme sommet du tour
      %% de la face gauche (en commencant par l indice 0). ATTENTION :
      %% utilise la variable globale n = nb d etages
      /sommettourgauche {
      1 dict begin
     /i exch def
     i 4 n mul ge {
        i
        (Error: indice trop grand dans sommettourgauche) ==
        exit
     } if
     n n 1 add i mul add
      end
      } def

      %% syntaxe : i sommetcentregauche --> l indice du i-eme sommet du centre
      %% de la face gauche (en commencant par l indice 0). ATTENTION :
      %% utilise les variables globales n = nb d etages, et N = nb sommets
      %% des 4 1eres faces
      /sommetcentregauche {
      1 dict begin
     /i exch def
     i n 1 sub dup mul ge {
        i
        (Error: indice trop grand dans sommetcentregauche) ==
        exit
     } if
     N i add
      end
      } def

      /F5 [
     %%%%% la face gauche %%%%%
     %% le coin superieur gauche
     [
        1 sommettourgauche
        0 sommettourgauche
        n 4 mul 1 sub sommettourgauche
        n1 n 1 sub sub sommetcentregauche
     ]

     %% la bande superieure (i from 1 to n-2)
     1 1 n 2 sub {
        /i exch def
        [
           i 1 add sommettourgauche
           i sommettourgauche
           n1 n sub i add sommetcentregauche
           n1 n sub i 1 add add sommetcentregauche
        ]
     } for

     %% le coin superieur droit
     [
        n sommettourgauche
        n 1 sub sommettourgauche
        n1 1 sub sommetcentregauche
        n 1 add sommettourgauche
     ]

     %% la descente gauche
     %% j from 1 to n-2
     1 1 n 2 sub {
        /j exch def
        [
           n1 n 1 sub j mul sub sommetcentregauche
           n 4 mul j sub sommettourgauche
           n 4 mul j 1 add sub sommettourgauche
           n1 n 1 sub j 1 add mul sub sommetcentregauche
        ]
     } for

     %% les bandes centrales (j from 1 to n-2 et i from 1 to n-2)
     1 1 n 2 sub {
        /j exch def
        1 1 n 2 sub {
           /i exch def
           [
          n1 i n 1 sub j 1 sub mul add sub sommetcentregauche
          n1 i 1 add n 1 sub j 1 sub mul add sub sommetcentregauche
          n1 i 1 add n 1 sub j mul add sub sommetcentregauche
          n1 i n 1 sub j mul add sub sommetcentregauche
           ]
        } for
     } for

     %% la descente droite
     1 1 n 2 sub {
        /j exch def
        [
           n j add sommettourgauche
           n1 1 sub j 1 sub n 1 sub mul sub sommetcentregauche
           n1 1 sub j n 1 sub mul sub sommetcentregauche
           n j 1 add add sommettourgauche
        ]
     } for

     %% le coin inferieur gauche
     [
        0 sommetcentregauche
        n 3 mul 1 add sommettourgauche
        n 3 mul sommettourgauche
        n 3 mul 1 sub sommettourgauche
     ]

     %% la bande inferieure (i from 1 to n-2)
     1 1 n 2 sub {
        /i exch def
        [
           i sommetcentregauche
           i 1 sub sommetcentregauche
           n 3 mul i sub sommettourgauche
           n 3 mul i sub 1 sub sommettourgauche
        ]
     } for

     %% le coin inferieur droit
     [
        n 2 mul 1 sub sommettourgauche
        n 2 sub sommetcentregauche
        n 2 mul 1 add sommettourgauche
        n 2 mul sommettourgauche
     ]
      ] def

      %% syntaxe : i sommettourdroit --> l indice du i-eme sommet du tour
      %% de la face droit (en commencant par l indice 0). ATTENTION :
      %% utilise la variable globale n = nb d etages
      /sommettourdroit {
      1 dict begin
     /i exch def
     i 4 n mul ge {
        i
        (Error: indice trop grand dans sommettourdroit) ==
        exit
     } if
     n 1 add i mul
      end
      } def

      %% syntaxe : i sommetcentredroit --> l indice du i-eme sommet du centre
      %% de la face droit (en commencant par l indice 0). ATTENTION :
      %% utilise les variables globales n = nb d etages, et N = nb sommets
      %% des 4 1eres faces
      /sommetcentredroit {
      1 dict begin
     /i exch def
     i n 1 sub dup mul ge {
        i
        (Error: indice trop grand dans sommetcentredroit) ==
        exit
     } if
     N n1 add i add
      end
      } def

      /F6 [
     %% coin superieur droit
     [
        0 sommettourdroit
        1 sommettourdroit
        n1 n 1 sub sub sommetcentredroit
        4 n mul 1 sub sommettourdroit
     ]
     %% coin superieur gauche
     [
        n 1 sub sommettourdroit
        n sommettourdroit
        n 1 add sommettourdroit
        n1 1 sub sommetcentredroit
     ]
     %% coin inferieur gauche
     [
        n 2 sub sommetcentredroit
        2 n mul 1 sub sommettourdroit
        2 n mul sommettourdroit
        2 n mul 1 add sommettourdroit
     ]
     %% coin inferieur droit
     [
        3 n mul 1 add sommettourdroit
        0 sommetcentredroit
        3 n mul 1 sub sommettourdroit
        3 n mul sommettourdroit
     ]
     %% bande superieure
     1 1 n 2 sub {
        /i exch def
        [
           i sommettourdroit
           i 1 add sommettourdroit
           n 1 sub n 2 sub mul i add sommetcentredroit
           n 1 sub n 2 sub mul i 1 sub add sommetcentredroit
        ]
     } for
     %% bande inferieure
     1 1 n 2 sub {
        /i exch def
        [
           i 1 sub sommetcentredroit
           i sommetcentredroit
           3 n mul 1 sub i sub sommettourdroit
           3 n mul i sub sommettourdroit
        ]
     } for
     %% descente gauche
     1 1 n 2 sub {
        /i exch def
        [
           n1 1 sub i 1 sub n 1 sub mul sub sommetcentredroit
           n i add sommettourdroit
           n i 1 add add sommettourdroit
           n1 1 sub i n 1 sub mul sub sommetcentredroit
        ]
     } for
     %% descente droite
     1 1 n 2 sub {
        /i exch def
        [
           4 n mul i sub sommettourdroit
           n 1 sub n 1 sub i sub mul sommetcentredroit
           n 1 sub n 2 sub i sub mul sommetcentredroit
           4 n mul i sub 1 sub sommettourdroit
        ]
     } for
     %% bandes interieures
     1 1 n 2 sub {
        /j exch def
        1 1 n 2 sub {
           /i exch def
           [
          n 1 sub j mul i 1 sub add sommetcentredroit
          n 1 sub j mul i add sommetcentredroit
          n 1 sub j 1 sub mul i add sommetcentredroit
          n 1 sub j 1 sub mul i 1 sub add sommetcentredroit
           ]
        } for
     } for

      ] def

      /F2 F1 {{n dup mul n add add} apply} apply def
      /F3 F2 {{n dup mul n add add} apply} apply def
      /F4 F3 {{n dup mul n add add} apply} apply def


      S1 S2 append S3 append S4 append S5 append S6 append {a mulv3d} papply3d
      F1 F2 append F3 append F4 append {{N mod} apply} apply F5 append F6 append
      generesolid
   } ifelse
end
} def

%%%%% ### newparallelepiped ### 
% 14 octobre 2006
/newparallelepiped {
2 dict begin
   /c exch 2 div def
   /b exch 2 div def
   /a exch 2 div def
   /F [
      [0 1 2 3]
      [0 4 5 1]
      [1 5 6 2]
      [2 6 7 3]
      [0 3 7 4]
      [4 7 6 5]
    ] def

    %% tableau des sommets
    /S [
       a     b     c %% 0
       a neg b     c %% 1
       a neg b neg c %% 2
       a     b neg c %% 3
       a     b     c neg %% 4
       a neg b     c neg %% 5
       a neg b neg c neg %% 6
       a     b neg c neg %% 7
    ] def
    S F generesolid
} def

%%%%% ### newcylindre ### 
%% syntaxe : z0 r0 z1 newcylindre -> solide
%% syntaxe : z0 r0 z1 {mode} newcylindre -> solide
%% syntaxe : z0 r0 z1 [n1 n2] newcylindre -> solide
%% syntaxe : a b {f} {u} h [n1 n2] newcylindre
/newcylindre {
2 dict begin
   [[/n2 /n1] [1 6] [1 8] [1 10] [3 12] [5 18]] gestionsolidmode
   2 copy pop xcheck {
      %% cylindre cas general
      /h exch def
      /U exch def
      U normalize3d /u defpoint3d
      /lafonction exch def
      /b exch def
      /a exch def
      /pas b a sub n1 div def
      /vpas h n2 div def
      /S [
         0 1 n2 {
            /j exch def
            0 1 n1 {
               /i exch def
               a i pas mul add lafonction
               u j vpas mul mulv3d addv3d
            } for
         } for
      ] def
      /F [
         0 1 n2 1 sub {
            /j exch def
            0 1 n1 1 sub {
               /i exch def
               [
                  i n1 1 add j mul add 
                  dup 1 add
                  dup n1 1 add add
                  dup 1 sub
               ]
            } for
         } for
      ] def
      
      S F generesolid
%      dup videsolid
   } {
      %% cylindre de revolution
      2 copy pop [n2 n1] newtronccone
   } ifelse
end
} def

%% syntaxe : z0 r0 z1 newcylindrecreux -> solide
/newcylindrecreux {
   newcylindre
   dup creusesolid
} def

%%%%% ### newtronccone ### 
%% syntaxe : z0 r0 z1 r1 newtronccone -> solid
/newtronccone {
11 dict begin
   [[/n /N] [1 6] [1 8] [1 10] [3 12] [5 18]] gestionsolidmode

   /r1 exch def
   /z1 exch def
   /r0 exch def
   /z0 exch def
   /dz z1 z0 sub n div def
   /dr r1 r0 sub n div def

   /FE [
      [0 1 N 1 sub {} for]
      [n 1 add N mul 1 sub -1 n N mul {} for]

      0 1 n 1 sub {
      /k exch def
         k N mul 1 add 1 k 1 add N mul 1 sub {
             /i exch def
             [i i 1 sub N i add 1 sub N i add]
         } for
         [k N mul k 1 add N mul 1 sub k 2 add N mul 1 sub k 1 add N mul]
      } for

   ] def

   %% tableau des sommets
   /S [
      n -1 0 {
         /k exch def
         0 1 N 1 sub {
             /i exch def
             360 N idiv i mul cos r0 dr k mul add mul
             360 N idiv i mul sin r0 dr k mul add mul
             z0 dz k mul add
         } for
      } for
   ] def
   S FE generesolid
end
} def

%% syntaxe : z0 r0 z1 r1 newtroncconecreux -> solid
/newtroncconecreux {
   newtronccone
   dup creusesolid
} def

%%%%% ### newcone ### 
%% syntaxe : z0 r0 z1 newcone -> solid
%% syntaxe : z0 r0 z1 {mode} newcone -> solid
%% syntaxe : z0 r0 z1 [n1 n2] newcone -> solid
%% syntaxe : a b {f} {sommet} [n1 n2] newcone -> solid
/newcone {
11 dict begin
   [ [/n /N] [1 6] [1 8] [1 10] [3 12] [5 18] ] gestionsolidmode
   dup xcheck {
      %% cas general
      /sommet exch def
      /lafonction exch def
      /b exch def
      /a exch def

      /pas b a sub N div def
      /S [
         sommet
         0 1 n 1 sub {
            /j exch def
            0 1 N {
               /i exch def
               a i pas mul add lafonction
               dupp3d sommet vecteur3d j n div mulv3d addv3d
            } for
         } for
         1 1 n {
            /j exch def
            0 1 N {
               /i exch def
               a i pas mul add lafonction
               sommet vecteur3d j n div mulv3d sommet addv3d
            } for
         } for
      ] def

      /F [
         %% les etages inferieurs
         0 1 n 2 sub {
            /j exch def
            1 1 N {
               /i exch def
               [
                  i j N 1 add mul add
                  dup 1 add
                  dup N add 1 add
                  dup 1 sub
               ]
            } for
         } for
         %% dernier etage inferieur
         1 1 N {
            /i exch def
            [
               i N 1 add n 1 sub mul add
               dup 1 add
               0
            ]
         } for
         %% premier etage superieur
         1 1 N {
            /i exch def
            [
               i N 1 add n mul add
               dup 1 add
               0
               exch
            ]
         } for
         %% les etages superieurs
         n 1 n 2 mul 2 sub {
            /j exch def
            1 1 N {
               /i exch def
               [
                  i j N 1 add mul add
                  dup 1 add
                  dup N add 1 add
                  dup 1 sub
               ]
            } for
         } for
      ] def

      S F generesolid
%      dup videsolid
   } {
      %% cylindre de revolution
      /z1 exch def
      /r0 exch def
      /z0 exch def
      /dz z1 z0 sub n div def
      /dr r0 n div def
   
      /F [
         %% la base
         [N 1 sub -1 0 {} for]
         %% le dernier etage
         n 1 sub N mul 1 add 1 n N mul 1 sub {
              /i exch def
              [i 1 sub i n N mul]
         } for
         [n N mul 1 sub n 1 sub N mul n N mul]
         %% les autres etages
         0 1 n 2 sub {
            /j exch def
            0 N j mul add 1 N N j mul add 2 sub {
               /i exch def
               [i i 1 add dup N add dup 1 sub]
            } for
            [N N j mul add 1 sub N j mul dup N add dup N add 1 sub]
         } for
      ] def
   
      %% tableau des sommets
      /S [
         %% etage no j (in [1; n])
         0 1 n 1 sub {
            /j exch def
            0 1 N 1 sub {
                /i exch def
                360 N idiv i mul cos r0 dr j mul sub mul
                360 N idiv i mul sin r0 dr j mul sub mul
                z0 dz j mul add
            } for
         } for
         0 0 z1
      ] def
      S F generesolid
   } ifelse
end
} def

%% %% syntaxe : z0 r0 z1 newconecreux -> solid
 /newconecreux {
    newcone
    dup 0 solidrmface
    dup videsolid
 } def

%%%%% ### newtore ### 
%% syntaxe : r R newtore -> solid
/newtore {
10 dict begin
   [[/n1 /n2] [4 5] [6 10] [8 12] [9 18] [18 36]] gestionsolidmode
   /n2 n2 3 max store
   /n1 n1 2 max store
   /R exch def
   /r exch def
   /S [
         0 1 n1 1 sub {
            /i exch def
            360 n1 div i mul cos r mul R add
            360 n1 div i mul sin r mul
         } for
      ]
   def
   S [n2] newanneau
end
} def

%%%%% ### newprisme ### 
%% syntaxe : array z0 z1 newprisme -> solid d axe (O, u),
/newprismedroit {
   [[/N] [1] [1] [1] [3] [6]] gestionsolidmode
   0 0 1 [N] newprisme
} def

%% syntaxe : array z0 z1 u newprisme -> solid d axe (O, u),
%% ou array tableau de points 2d
/newprisme {
7 dict begin
   [[/N] [1] [1] [1] [3] [6]] gestionsolidmode
   dup 0 eq {
      (Error : 3eme composante nulle dans le vecteur pour newprisme) ==
      quit
   } if
   /u defpoint3d
   /z1 exch def
   /z0 exch def
   %% N = nb d etages
   /table exch def
   %% n = indice du dernier point
   /n table length 2 idiv 1 sub def
   %% vecteur de translation
   u
   z1 z0 sub u norme3d div
   mulv3d /v defpoint3d

   %% tableau des sommets
   /S [
      0 1 N {
         /j exch def
         0 1 n {
             /i exch def
             table i getp
             z0
             v N j sub N div mulv addv3d
         } for
      } for
   ] def

   /F [ 
      %% face superieure
      [0 1 n {} for]
      %% base
      [N 1 add n 1 add mul 1 sub -1 N n 1 add mul {} for]
      %% faces etage
      1 1 N {
         /j exch def
         1 1 n {
             /i exch def
             [i                   j 1 sub n 1 add mul add
              i 1 sub             j 1 sub n 1 add mul add
              n 1 add i add 1 sub j 1 sub n 1 add mul add
              n 1 add i add       j 1 sub n 1 add mul add]
         } for
         [0            j 1 sub n 1 add mul add
         n             j 1 sub n 1 add mul add
         2 n mul 1 add j 1 sub n 1 add mul add
         n 1 add       j 1 sub n 1 add mul add]
     } for
   ] def

   S F generesolid
end
} def

%%%%% ### newsphere ### 
%% syntaxe : r option newsphere -> solid
/newsphere {
2 dict begin
   [[/K /N] [6 6] [8 8] [10 12] [16 12] [16 36]] gestionsolidmode
   -90 90 [K N] newcalottesphere
end
} def

%% syntaxe : r phi theta option newcalottesphere -> solid
/newcalottesphere {
6 dict begin
   [[/K /N] [6 6] [8 8] [10 12] [16 12] [16 36]] gestionsolidmode

   %% test de beta (ex-theta)
   dup 90 eq {
      /beta exch def
      /idebut 1 def
   } {
      /beta exch 80 min -80 max def
      /idebut 0 def
   } ifelse
   %% test de alpha (ex-phi)
   dup -90 eq {
      /alpha exch def
   } {
      /alpha exch beta min -80 max def
   } ifelse
   /r exch def
   beta 90 eq {
       alpha -90 eq {
           /ifin K def
          /db alpha beta sub K 1 add div def
       } {
           /ifin K def
          /db alpha beta sub K div def
       } ifelse
   } {
       alpha -90 eq {
           /ifin K 1 sub def
          /db alpha beta sub K div def
       } {
           /ifin K 1 sub def
          /db alpha beta sub K 1 sub div def
       } ifelse
   } ifelse

   %% nombre de sommets -2
   /nb N K mul def

   %% tableau des sommets
   /S [
       idebut 1 ifin {
           /j exch def
           /phi beta j db mul add def
           phi cos r mul /r_tmp exch def
           0 1 N 1 sub {
                /i exch def
                360 N idiv i mul cos r_tmp mul
                360 N idiv i mul sin r_tmp mul
                phi sin r mul
            } for
       } for
      0 0 r neg
      0 0 r
   ] def

   /F [
     %% calotte inferieure
     alpha -90 eq {
         1 1 N 1 sub {
         /i exch def
            [
                nb
                nb i sub
                nb i 1 add sub
            ]
         } for
         [nb nb N sub nb 1 sub]
     } {
        [nb 1 sub -1 nb N sub {} for ]
     } ifelse

     %% calotte superieure
     beta 90 eq {
         0 1 N 1 sub {
            /i exch def
             [i i 1 add N mod N K mul 1 add]
         } for
      } {
         [0 1 N 1 sub {} for]
      } ifelse

     1 1 K 1 sub {
          /j exch def
       [
           j N mul
           j N mul 1 add
           j 1 sub N mul 1 add
           j 1 sub N mul
       ]
       N 2 sub {dup {1 add} apply} repeat
       [
           j 1 add N mul 1 sub
           j N mul
           j 1 sub N mul
           j N mul 1 sub
       ]
    } for
   ] def

   S F generesolid
end
} def

%% syntaxe : r phi theta option newcalottespherecreuse -> solid
/newcalottespherecreuse {
6 dict begin
   [[/K /N] [6 6] [8 8] [10 12] [16 12] [16 36]] gestionsolidmode

   %% test de beta (ex-theta)
   dup 90 eq {
      /beta exch def
      /idebut 1 def
   } {
      /beta exch 80 min -80 max def
      /idebut 0 def
   } ifelse
   %% test de alpha (ex-phi)
   dup -90 eq {
      /alpha exch def
   } {
      /alpha exch beta min -80 max def
   } ifelse
   /r exch def
   beta 90 eq {
       alpha -90 eq {
           /ifin K def
          /db alpha beta sub K 1 add div def
       } {
           /ifin K def
          /db alpha beta sub K div def
       } ifelse
   } {
       alpha -90 eq {
           /ifin K 1 sub def
          /db alpha beta sub K div def
       } {
           /ifin K 1 sub def
          /db alpha beta sub K 1 sub div def
       } ifelse
   } ifelse

   %% nombre de sommets -2
   /nb N K mul def

   %% tableau des sommets
   /S [
       idebut 1 ifin {
           /j exch def
           /phi beta j db mul add def
           phi cos r mul /r_tmp exch def
           0 1 N 1 sub {
                /i exch def
                360 N idiv i mul cos r_tmp mul
                360 N idiv i mul sin r_tmp mul
                phi sin r mul
            } for
       } for
      0 0 r neg
      0 0 r
   ] def

   /F [
     %% calotte inferieure
     alpha -90 eq {
         1 1 N 1 sub {
         /i exch def
            [
                nb
                nb i sub
                nb i 1 add sub
            ]
         } for
         [nb nb N sub nb 1 sub]
     } {
%        [nb 1 sub -1 nb N sub {} for ]
     } ifelse

     %% calotte superieure
     beta 90 eq {
         0 1 N 1 sub {
            /i exch def
             [i i 1 add N mod N K mul 1 add]
         } for
      } {
%         [0 1 N 1 sub {} for]
      } ifelse

     1 1 K 1 sub {
          /j exch def
       [
           j N mul
           j N mul 1 add
           j 1 sub N mul 1 add
           j 1 sub N mul
       ]
       N 2 sub {dup {1 add} apply} repeat
       [
           j 1 add N mul 1 sub
           j N mul
           j 1 sub N mul
           j N mul 1 sub
       ]
    } for
   ] def

   S F generesolid
   dup videsolid
end
} def

%%%%% ### newanneau ### 
%% syntaxe : array n newanneau --> solid
%% syntaxe : array {mode} newanneau --> solid
%% ou array est un tableau de points de R^2 et n un nombre entier positif
/newanneau {
10 dict begin
   dup isnum {
      /n exch def
      [n]
   } if
   [[/n2] [6] [12] [24] [32] [36]] gestionsolidmode
   /n2 n2 3 max store
   %% on plonge la section dans R^3 par projection sur yOz
   /S1 exch {0 3 1 roll} papply def
   %% nombre de sommets
   /n1 S1 length 3 idiv def

   /S S1
      n2 {
         duparray
         {0 0 360 n2 div rotateOpoint3d} papply3d
      } repeat
      n2 {append} repeat
   def

   /F [
      0 1 n2 1 sub {
         /j exch def
         n1 j mul 1 j 1 add n1 mul 2 sub {
            /i exch def
            [i 1 add i dup n1 add i n1 1 add add]
         } for
         [n1 j mul j 1 add n1 mul 1 sub j 2 add n1 mul 1 sub j 1 add n1 mul]
      } for
   ] def

   S F generesolid
end
} def

%%%%% ### newvecteur ### 
%% syntaxe : x y z newvecteur
%% syntaxe : x y z array newvecteur
/newvecteur {
4 dict begin
   dup isarray {
      /table exch def
      /h@uteur table 1 get def
      /r@y@n table 0 get def
   } {
      /h@uteur .3 def
      /r@y@n .1 def
   } ifelse
   /A defpoint3d
   %%Sommets
   /S [0 0 0 A] def
   /F [
      [0 1]
   ] def
   S F generesolid
   [ A ]
   normalvect_to_orthobase
   /imK defpoint3d
   /imJ defpoint3d
   /imI defpoint3d

   A norme3d /z exch h@uteur sub def 
   0 r@y@n h@uteur [1 8] newcone
   dup (noir) outputcolors
   {0 0 z translatepoint3d} solidtransform
   {imI imJ imK transformpoint3d} solidtransform
   solidfuz
end
} def

%%%%% ### readsolidfile ###
%% syntaxe : str readsolidfile -> solid
/readsolidfile {
1 dict begin
   /str exch def
   [str (-sommets.dat) append run] 
   [str (-faces.dat) append run]
   generesolid
   dup [str (-couleurs.dat) append run] solidputfcolors
   dup [str (-io.dat) append run] solidputinouttable
end
} def

%%%%% ### writesolidfile ###
%% syntaxe : solid str writesolidfile -> -
/writesolidfile {
10 dict begin
   /str exch def
   /solid exch def
   solid issolid not {
      (Error : mauvais type d argument dans writesolidfile) ==
      quit
   } if
   str (-sommets.dat) append (w) file /lefichiersommets exch def
   str (-faces.dat) append (w) file /lefichierfaces exch def
   str (-couleurs.dat) append (w) file /lefichiercouleurs exch def
   str (-io.dat) append (w) file /lefichierio exch def

   /S solid solidgetsommets def
   0 1 S length 3 idiv 1 sub {
      /i exch def
      solid i solidgetsommet
      /z exch def
      /y exch def
      /x exch def
      lefichiersommets x chaine cvs writestring
      lefichiersommets 32 write %% espace
      lefichiersommets y chaine cvs writestring
      lefichiersommets 32 write %% espace
      lefichiersommets z chaine cvs writestring
      lefichiersommets 10 write %% CR
   } for
   lefichiersommets closefile

   /F solid solidgetfaces def
   0 1 F length 1 sub {
      /i exch def
      /Fi solid i solidgetface def
      lefichierfaces 91 write %% [
      0 1 Fi length 1 sub {
         /j exch def
         lefichierfaces Fi j get chaine cvs writestring
         lefichierfaces 32 write %% espace
      } for
      lefichierfaces 93 write %% ]
      lefichierfaces 10 write %% CR
   } for
   lefichierfaces closefile

   /C solid solidgetfcolors def
   0 1 C length 1 sub {
      /i exch def
      lefichiercouleurs 40 write %% (
      lefichiercouleurs C i get writestring
      lefichiercouleurs 41 write %% )
      lefichiercouleurs 10 write %% CR
   } for
   lefichiercouleurs closefile

   /IO solid solidgetinouttable def
   0 1 3 {
      /i exch def
      lefichierio IO i get chaine cvs writestring
      lefichierio 32 write %% space
   } for
   lefichierio closefile
end
} def

%%%%% ### writeobjfile ###
%% syntaxe : solid str writeobjfile -> -
/writeobjfile {
10 dict begin
   /str exch (.obj) append def
   /solid exch def
   solid issolid not {
      (Erreur : mauvais type d argument dans writeobjfile) ==
      quit
   } if
   /n solid solidnombresommets def
   str (w) file /lefichier exch def
   0 1 n 1 sub {
      /i exch def
      solid i solidgetsommet
      /z exch def
      /y exch def
      /x exch def
      lefichier (v ) writestring
      lefichier x chaine cvs writestring
      lefichier 32 write %% espace
      lefichier y chaine cvs writestring
      lefichier 32 write %% espace
      lefichier z chaine cvs writestring
      lefichier 10 write %% CR
   } for
   /n solid solidnombrefaces def
   0 1 n 1 sub {
      /i exch def
      lefichier (f ) writestring
      /F solid i solidgetface {1 add} apply def
      F {
         lefichier exch
         chaine cvs writestring
         lefichier  32  write %% espace
      } apply
      lefichier  10  write %% CR
   } for
   lefichier closefile
end
} def

%%%%% ### writeofffile ###
%% syntaxe : solid str writeobjfile -> -
/writeofffile {
12 dict begin
   /str exch (.off) append def
   /solid exch def
   solid issolid not {
      (Erreur : mauvais type d argument dans writeofffile) ==
      quit
   } if
   /n solid solidnombresommets def
   /nf solid solidnombrefaces def
   str (w) file /lefichier exch def
   lefichier (OFF) writestring
   lefichier 10 write %% CR
   lefichier n chaine cvs writestring
   lefichier 32 write %% espace
   lefichier nf chaine cvs writestring
   lefichier 32 write %% espace
   lefichier 0 chaine cvs writestring
   lefichier 10 write %% CR
   0 1 n 1 sub {
      /i exch def
      solid i solidgetsommet
      /z exch def
      /y exch def
      /x exch def
      lefichier z chaine cvs writestring
      lefichier 32 write %% espace
      lefichier y chaine cvs writestring
      lefichier 32 write %% espace
      lefichier x chaine cvs writestring
      lefichier 10 write %% CR
   } for
   0 1 nf 1 sub {
      /i exch def
      /F solid i solidgetface def
      lefichier F length chaine cvs writestring
      lefichier 32 write %% espace
      F {
         lefichier exch
         chaine cvs writestring
         lefichier  32  write %% espace
      } apply
      lefichier  10  write %% CR
   } for
   lefichier closefile
end
} def

%%%%% ### newobjfile ###
/newobjfile {
3 dict begin
   /objfilename exch (.obj) append def
   /v {} def
   /ok true def
   /f {
       ok {
        %% 1ere fois
           ] %% ferme les sommets
        [ [ %% ouvre les faces
        /ok false store
       } {
        %% les autres fois
           ] %% ferme la face
        [ %% ouvre la nouvelle
       } ifelse
   } def
   [ 0 0 0 %% sommet fantome pour respecter l'indexation (a partir de l'indice 1)
   objfilename run
   ]]
   /F exch def
   /S exch def

   S F generesolid
%   dup videsolid
end
} def

%%%%% ### newofffile ###
/newofffile {
3 dict begin
   /str 35 string def
   /offfilename exch (.off) append def
   offfilename (r) file
   /offfile exch def
   offfile str readline pop pop
   offfile str readline pop
   numstr2array
   dup 0 get /ns exch def
   1 get /nf exch def
   [ns {
      offfile str readline pop numstr2array aload pop
      3 1 roll
   } repeat]
   /S exch def
   [nf {
      [
      offfile str readline pop numstr2array
      /table exch def
      1 1 table length 1 sub {
         /i exch def
         table i get
      } for
      ]
   } repeat]
   /F exch def

   S F generesolid
%   dup videsolid
end
} def

%%%%% ### newtube ###
 /tub@dernierk1 [1 0 0] def
 /tub@dernierk2 [0 1 0] def
 /tub@dernierk3 [0 0 1] def

/inittube {
2 dict begin
   normalize3d /vect3 defpoint3d
   normalize3d /vect2 defpoint3d
   normalize3d /vect1 defpoint3d
   vect1 norme3d 0 eq {
      vect2 vect3 vectprod3d /vect1 defpoint3d
   } if
   vect2 norme3d 0 eq {
      vect3 vect1 vectprod3d /vect2 defpoint3d
   } if
   vect3 norme3d 0 eq {
      vect1 vect2 vectprod3d /vect3 defpoint3d
   } if
   /tub@dernierk1 [vect1] store
   /tub@dernierk2 [vect2] store
   /tub@dernierk3 [vect3] store
end
} def
 
%% syntaxe : tmin tmax (f) array r newtube -> solid
%% array = [K N]
/newtube {
10 dict begin
   /table exch def
   /K table 0 get def %% nb d etages
   /N table 1 get def %% nb de points sur le perimetre
   /@r exch def       %% le rayon du tube
   /str exch def
   /lafonction str cvx def
   /laderivee str (') append cvx def
%%   /laderivee2nd str ('') append cvx def
   /tmax exch def
   /tmin exch def
   /pas tmax tmin sub K 1 sub div def

   %% definition des sommets
   [
   /@k 0 def
   K {
      /a0 tmin @k pas mul add def
   
      %% definition du repere de Frenet (k1, k2, k3) au point f(a)
      a0 lafonction /M defpoint3d

      str (') append cvlit where {
         pop 
         a0 laderivee normalize3d /k1 defpoint3d
%         pop /avecderiv true def
      } {
         M a0 pas 100 div add lafonction vecteur3d normalize3d /k1 defpoint3d
%         /avecderiv false
      } ifelse

      k1 baseplannormal /K3 defpoint3d /K2 defpoint3d
%      a0 laderivee2nd normalize3d /k2 defpoint3d

      %% projete orthogonal du dernier rayon sur le plan actuel
      %% (normal a la vitesse)
      K2 tub@dernierk2 aload pop K2 scalprod3d mulv3d 
      K3 tub@dernierk2 aload pop K3 scalprod3d mulv3d addv3d /k2 defpoint3d
%      M k1 K2 K3 dessinebase
      k1 norme3d 0 eq {
         tub@dernierk1 aload pop /k1 defpoint3d
      } {
         /tub@dernierk1 [k1] store
      } ifelse
      k2 norme3d 0 eq {
         tub@dernierk2 aload pop /k2 defpoint3d
      } {
         /tub@dernierk2 [k2] store
      } ifelse
      k1 k2 vectprod3d normalize3d /k3 defpoint3d
      k3 norme3d 0 eq {
          tub@dernierk3 aload pop /k3 defpoint3d
      } {
         /tub@dernierk3 [k3] store
      } ifelse
      k3 k1 vectprod3d normalize3d /k2 defpoint3d
%%      M k1 k2 k3 dessinebase
      /tub@dernierk2 [k2] store
      /@n 360 N div def %% le pas angulaire
      0 @n 360 @n sub {
         /@i exch def
         M
         k2 @i cos @r mul mulv3d addv3d
         k3 @i sin @r mul mulv3d addv3d
      } for
      /@k @k 1 add store
   } repeat
   ]

   dup length 3 idiv /nb exch def
   %% definition des faces
   [
      %% face de depart
      [N 1 sub -1 0 {} for]
      %% face d arrivee
      [nb 1 sub N 1 sub {dup 1 sub} repeat] reverse
   
      %% les etages
      /j 0 def
      K 1 sub {
         0 1 N 1 sub {
            /i exch def
            [
               i                   N j mul add
               i 1 add N mod       N j mul add
               i 1 add N mod N add N j mul add
               i N add             N j mul add
            ]
         } for
         /j j 1 add store
      } repeat
   ]
   generesolid
end
} def

%%%%% ### newcourbe ###
%% syntaxe : a b {f} array newcourbe --> solid
/newcourbe {
10 dict begin
   dup xcheck not {
      0 get /n exch def
   } {
      /n 80 def
   } ifelse
   /l@f@nct exch def
   /b exch def
   /a exch def
   /pas b a sub n 1 sub div def
   /S [
   0 1 n 1 sub {
      /@i exch def
      a @i pas mul add
      l@f@nct
      pstrickactionR3
   } for
   ] def
   /@F [
      0 1 n 2 sub {
         /@i exch def
         [@i @i 1 add]
      } for
   ] def
   S @F generesolid
end
} def

%%%%% ### baseplannormal ###
%% syntaxe : x y z baseplannormal -> x1 y1 z1 x2 y2 z2
/baseplannormal {
5 dict begin
   /K defpoint3d
   1 0 0 K vectprod3d normalize3d /U defpoint3d
   U norme3d 0 eq {
      0 1 0 K vectprod3d normalize3d /U defpoint3d
   } if
   K U vectprod3d normalize3d /V defpoint3d
   U V
end
} def

%%%%% ### fin insertion ###

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%                                                    %%%%
%%%%      fin insertion librairie jps                   %%%%
%%%%                                                    %%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%          gestion de chaine de caracteres           %%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

/Times-Roman findfont 
dup length dict begin
   {
   1 index /FID ne 
      {def}
      {pop pop} 
   ifelse
   } forall
   /Encoding ISOLatin1Encoding def
   currentdict
end
/Times-Roman-ISOLatin1 exch definefont pop

/setTimesRoman {
   /Times-Roman-ISOLatin1 findfont 
   fontsize scalefont 
   setfont
} def

/setTimes {
   setTimesRoman
} def

%% syntaxe : string x y cctext
/cctext {
5 dict begin
   /y exch def
   /x exch def
   /str exch def
   str stringwidth
   /wy exch def
   /wx exch def
   gsave
      x y smoveto
      wx -2 div wy -2 div rmoveto
      str show
   grestore
end
} def

/dbtext {gsave newpath dbtext_ Fill grestore} def
/dctext {gsave newpath dctext_ Fill grestore} def
/dltext {gsave newpath dltext_ Fill grestore} def
/drtext {gsave newpath drtext_ Fill grestore} def

/bbtext {gsave newpath bbtext_ Fill grestore} def
/bctext {gsave newpath bctext_ Fill grestore} def
/bltext {gsave newpath bltext_ Fill grestore} def
/brtext {gsave newpath brtext_ Fill grestore} def

/cbtext {gsave newpath cbtext_ Fill grestore} def
/cctext {gsave newpath cctext_ Fill grestore} def
/cltext {gsave newpath cltext_ Fill grestore} def
/crtext {gsave newpath crtext_ Fill grestore} def

/ubtext {gsave newpath ubtext_ Fill grestore} def
/uctext {gsave newpath uctext_ Fill grestore} def
/ultext {gsave newpath ultext_ Fill grestore} def
/urtext {gsave newpath urtext_ Fill grestore} def


%% syntaxe : str x y show_dim --> str x y llx lly wx wy 
%% attention, doit laisser la pile intacte
/show_dim {
   3 copy pop pop
   newpath
      0 0 moveto
      true charpath flattenpath pathbbox 
   closepath
   newpath
} def

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%             procedures pour PSTricks               %%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%%% les 3 procedures utilisees pour transformer les depots de AlgToPs en nombres
/pstrickactionR3 { 
3 dict begin 
  /len@3 exch def 
  /len@2 exch def 
  /len@1 exch def 
  len@1 exec 
  len@2 exec 
  len@3 exec 
end 
} def 

/pstrickactionR2 {
   exec exch exec exch
} def

/pstrickactionR {
   exec
} def

/gere_pst-deffunction {
   counttomark
   dup 1 eq {
      pop
      pstrickactionR
      ] aload pop
   } {
      2 eq {
         pstrickactionR2
         ] aload pop
      } {
         pstrickactionR3
         ] aload pop
      } ifelse
   } ifelse
} def

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%             procedures pour \psSolid               %%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

/all (all) def

/draw {drawsolid} def
/draw* {drawsolid*} def
/draw** {drawsolid**} def
/writeobj {solidfilename writeobjfile} def
/writesolid {solidfilename writesolidfile} def
/writeoff {solidfilename writeofffile} def
/none {pop} def
/vecteur_en_c@urs false def

/gere_pstricks_color_inout {
   gsave
      dup  [fillincolor] (setrgbcolor) astr2str
         [fillcolor] (setrgbcolor) astr2str inoutputcolors
   grestore
} def

/gere_pstricks_color_out {
   gsave
      dup  [fillcolor] (setrgbcolor) astr2str outputcolors
   grestore
} def

/gere_pstricks_opt {
%   /CourbeR2 {CourbeR2+} def
   linecolor
   linestyle
   solidlinewidth setlinewidth
   solidtrunc length 0 ne {
      solidtrunc 0 get isstring {
         dup trunccoeff solidtronque
      } {
         dup solidtrunc trunccoeff solidtronque
      } ifelse
   } if
   solidgeode {
      1 newgeode
   } if
   soliddualreg {
      dualpolyedreregulier
   } if
   chanfrein {
      dup chanfreincoeff solidchanfreine
   } if
   RotX 0 ne RotY 0 ne or RotZ 0 ne or {
      {RotX RotY RotZ rotateOpoint3d} solidtransform
   } if
   CX 0 ne CY 0 ne or CZ 0 ne or {
      {CX CY CZ translatepoint3d} solidtransform
   } if
   plansection length 0 gt {
      0 1 plansection length 1 sub {
         /i exch def
         plansection i get solidplansection
         dup 0 solidrmface
      } for
   } if
   /rmfaces rmfaces bubblesort reverse store
   0 1 rmfaces length 1 sub {
      /i exch def
      dup rmfaces i get solidrmface
   } for
   tx@Dict /pst-transformoption known {
      dup {pst-transformoption} solidtransform 
   } if
   solidaffinage length 0 ne {
      %% si on affine, il faut colorier avant
      activationgestioncouleurs {
         gere_pstricks_color_out
      } if
      solidaffinage 0 get isstring {
         dup affinagecoeff
         /solidfcolor where {
            pop
            solidfcolor
         } if
         affinagerm solidaffine
      } {
         dup affinagecoeff solidaffinage
         /solidfcolor where {
            pop
            solidfcolor
         } if
         affinagerm solidaffine
      } ifelse
      %% et il faut evider et coloriier l'interieur si necessaire
      solidhollow {
         dup videsolid
         activationgestioncouleurs {
            gsave
               dup  [fillincolor] (setrgbcolor) astr2str inputcolors
            grestore
         } if
      } if
      /activationgestioncouleurs false def
   } if
   tx@Dict /plansepare known {
      plansepare solidplansepare
      tx@Dict /plansepare undef
      tx@Dict /solidname known {
         solidname (1) append cvlit exch def
         dup solidname (0) append cvlit exch def
         %%
         solidname (1) append cvx exec
         solidhollow {
            dup videsolid
         } if
         activationgestioncouleurs {
            dup solidwithinfaces {
               gere_pstricks_color_inout 
            } {
               gere_pstricks_color_out
            } ifelse
         } if
         solidinouthue length 0 gt { 
            dup solidinouthue solidputinouthuecolors 
         } {
            solidhue length 0 gt {
               dup solidhue solidputhuecolors
            } if
            solidinhue length 0 gt {
               dup solidinhue solidputinhuecolors
            } if
         } ifelse
         pop
         tx@Dict /solidname undef
      } {
         /solid1 exch def
         /solid2 exch def
      } ifelse
   } if
   solidhollow {
      dup videsolid
   } if
   activationgestioncouleurs {
      dup solidwithinfaces {
         gere_pstricks_color_inout 
      } {
         gere_pstricks_color_out
      } ifelse
      solidinouthue length 0 gt { 
         dup solidinouthue solidputinouthuecolors 
      } {
         solidhue length 0 gt {
            dup solidhue solidputhuecolors
         } if
         solidinhue length 0 gt {
            dup solidinhue solidputinhuecolors
         } if
      } ifelse
   } if

   0 1 fcol length 2 idiv 1 sub {
      /i exch def 
      dup fcol 2 i mul get fcol 2 i mul 1 add get solidputfcolor
   } for
   vecteur_en_c@urs not {
      /lightsrc where {pop solidlightOn} if
   } {
      /vecteur_en_c@urs false def
   } ifelse
   dup action cvx exec
   noir
   solidnumf length 0 ne {
      solidnumf 0 get isstring {
         dup projectionsifacevisible solidnumfaces
      } {
         dup solidnumf projectionsifacevisible solidnumfaces
      } ifelse
   } if
   solidshow length 0 ne {
      solidshow 0 get isstring {
         dup solidshowsommets
      } {
         dup solidshow solidshowsommets
      } ifelse
   } if
   solidnum length 0 ne {
      solidnum 0 get isstring {
         dup solidnumsommets
      } {
         dup solidnum solidnumsommets
      } ifelse
   } {
      %% pop
   } ifelse
   tx@Dict /solidname known {
      solidname cvlit exch bind def
      tx@Dict /solidname undef
   } {
      pop
   } ifelse
} def

/pst-octahedron {
   a newoctaedre
   gere_pstricks_opt
} def

/pst-dodecahedron {
   a newdodecaedre
   gere_pstricks_opt
} def

/pst-icosahedron {
   a newicosaedre
   gere_pstricks_opt
} def

/pst-cube {
   a
   ngrid length 1 eq {
      ngrid
   } {
      {Mode}
   } ifelse
   newcube 
%%    solidhollow {
%%       dup videsolid
%%    } if
   gere_pstricks_opt
} def

/pst-parallelepiped {
   a b c
   newparallelepiped
   gere_pstricks_opt
} def

/pst-tetrahedron {
   r newtetraedre
   gere_pstricks_opt
} def

/pst-tore {
   r0 r1
   ngrid length 2 eq {
      ngrid
   } {
      {Mode}
   } ifelse
   newtore
   gere_pstricks_opt
} def

/pst-sphere {
   % rayon
   % mode
  %   r {Mode} newsphere
   r
   ngrid length 2 eq {
      ngrid
   } {
      {Mode}
   } ifelse
   newsphere
   gere_pstricks_opt
} def

/pst-cylindre {
   /save-cylinderhollow solidhollow def
   tx@Dict /function known {
      range aload pop function cvx {axe} h ngrid newcylindre
      tx@Dict /function undef
      /solidhollow true def
   } {
      % rayon
      % mode
      0 r h
      ngrid length 2 eq {
         ngrid
      } {
         {Mode}
      } ifelse
      newcylindre
      solidhollow {
         dup creusesolid
      } if
   } ifelse
   gere_pstricks_opt
   /solidhollow save-cylinderhollow store
} def

/pst-cylindrecreux {
   % rayon
   % mode
   0 r h
   ngrid length 2 eq {
      ngrid
   } {
      {Mode}
   } ifelse
   newcylindre
   dup creusesolid
   gere_pstricks_opt
} def

/pst-cone {
   /save-conehollow solidhollow def
   tx@Dict /function known {
      range aload pop function cvx {origin} ngrid newcone
      tx@Dict /function undef
      /solidhollow true def
   } {
      % rayon
      % mode
      0 r h
      ngrid length 2 eq {
         ngrid
      } {
         {Mode}
      } ifelse
      solidhollow {
         newconecreux
      } {
         newcone
      } ifelse
   } ifelse
   gere_pstricks_opt
   /solidhollow save-conehollow store
} def

/pst-tronccone {
   % rayon
   % mode
   0 r0 h r1
   ngrid length 2 eq {
      ngrid
   } {
      {Mode}
   } ifelse
   solidhollow {
      newtroncconecreux
   } {
      newtronccone
   } ifelse
   gere_pstricks_opt
} def

/pst-troncconecreux {
   % rayon
   % mode
   0 r0 h r1
   ngrid length 2 eq {
      ngrid
   } {
      {Mode}
   } ifelse
   newtroncconecreux
   gere_pstricks_opt
} def

/pst-conecreux {
   % rayon
   % mode
   0 r h
   ngrid length 2 eq {
      ngrid
   } {
      {Mode}
   } ifelse
   newconecreux
   gere_pstricks_opt
} def

/pst-anneau {
   [ section ]
   ngrid length 1 ge {
      [ngrid 0 get]
   } {
      [24]
   } ifelse
   newanneau
   gere_pstricks_opt
} def


/pst-prisme {
   % tableau des points de la base
   % h hauteur du prisme
   % axe : vecteur direction de l axe
   base decal rollparray
   0 h axe
   ngrid length 1 ge {
      [ngrid 0 get]
   } if
   newprisme
   solidhollow {
      dup creusesolid
   } if
   gere_pstricks_opt
} def

/pst-prismecreux {
   % tableau des points de la base
   % h hauteur du prisme
   % axe : vecteur direction de l axe
   base
   0 h axe
   ngrid length 1 ge {
      [ngrid 0 get]
   } if
   newprisme
   dup creusesolid
   gere_pstricks_opt
} def

/pst-grille {
   base aload pop
   ngrid length 2 ge {
      [ngrid 0 get ngrid 1 get]
   } {
      ngrid length 1 eq {
         [ngrid 0 get dup]
      } if
   } ifelse
   newgrille
   gere_pstricks_opt
} def

%% syntaxe : array N h u newruban -> solid d axe (O, u),
/pst-ruban {
   % tableau des points de la base
   % h hauteur du prisme
   % axe : vecteur direction de l axe
   base
   h axe 
   ngrid length 1 ge {
      [ngrid 0 get]
   } if
   newruban
   gere_pstricks_opt
} def

%% syntaxe : r phi option newcalottesphere -> solid
/pst-calottesphere {
   % rayon
   % mode
   % r phi theta option newcalottesphere
   r
   phi theta
   ngrid length 2 eq {
      ngrid
   } {
      {Mode}
   } ifelse
   solidhollow {
      newcalottespherecreuse
   } {
      newcalottesphere
   } ifelse
   gere_pstricks_opt
} def

%% syntaxe : r phi option newcalottesphere -> solid
/pst-calottespherecreuse {
   % rayon
   % mode
   % r phi theta option newcalottespherecreuse
   r
   phi theta
   ngrid length 2 eq {
      ngrid
   } {
      {Mode}
   } ifelse
   newcalottespherecreuse
   gere_pstricks_opt
} def

/pointtest{2 2 2} def

/pst-face {
   % tableau des points de la base
   % h hauteur du prisme
   % axe : vecteur direction de l axe
   base
   solidbiface {
      newbiface
   } {
      newmonoface 
   } ifelse
   gere_pstricks_opt
} def

/pst-surface {
   base
   base aload pop
   ngrid length 2 ge {
      [ngrid 0 get ngrid 1 get]
   } {
      ngrid length 1 eq {
         [ngrid 0 get dup]
      } ifelse
   } ifelse
   {f} newsurface
   solidbiface {
      dup videsolid
   } if
   gere_pstricks_opt
} def

/pst-polygoneregulier {
   r ngrid 0 get
   newpolreg
   solidbiface {
   } {
      dup 1 solidrmface
   } ifelse
   gere_pstricks_opt
} def

/pst-fusion {
1 dict begin
   /activationgestioncouleurs false def
   /n base length def
   base aload pop n 1 sub {solidfuz} repeat
   gere_pstricks_opt
end
} def

/pst-new {
   sommets faces
   generesolid
%%    solidhollow {
%%       dup videsolid
%%    } if
   gere_pstricks_opt
} def

/pst-courbe {
   solidlinewidth setlinewidth
   r 0 eq {
      range aload pop function cvx [resolution] newcourbe
      gere_pstricks_opt
   } {
      range aload pop function r ngrid newtube
      gere_pstricks_opt %% r function [36 12] newtube
   } ifelse
} def

/pst-surfaceparametree {
   base aload pop
   ngrid length 2 ge {
      [ngrid 0 get ngrid 1 get]
   } {
      ngrid length 1 eq {
         [ngrid 0 get dup]
      } if
   } ifelse
   { function cvx exec } newsurfaceparametree
   dup videsolid
   gere_pstricks_opt
} def

/pst-surface* {
   r
   ngrid length 2 ge {
      [ngrid 0 get ngrid 1 get]
   } {
      ngrid length 1 eq {
         [ngrid 0 get dup]
      } if
   } ifelse
   { function cvx exec } newsurface*
   dup videsolid
   gere_pstricks_opt
} def

/pst-vecteur {
gsave
   /activationgestioncouleurs false def
   /vecteur_en_c@urs true def
   solidlinewidth setlinewidth
   2 setlinejoin
   1 setlinecap
   linecolor
   linestyle
   tx@Dict /solidname known {
      texte args definition cvx exec
      solidname cvlit exch defpoint3d
      tx@Dict /solidname undef
   } if
   args definition cvx exec newvecteur
   dup
   gsave
      [linecolor currentrgbcolor] ( ) astr2str (setrgbcolor) append 
      outputcolors
   grestore
   gere_pstricks_opt
grestore
} def

%/pst-vect- {} def
%/pst-vect-2points {vecteur3d} def
/pst-line {
   gsave
      linestyle 
      linecolor
      [args] ligne3d
   grestore
} def

/pst-objfile {
   solidfilename newobjfile
   gere_pstricks_opt
} def

/pst-offfile {
   solidfilename newofffile
   gere_pstricks_opt
} def

/pst-datfile {
   solidfilename readsolidfile
%   /activationgestioncouleurs false def
   gere_pstricks_opt
} def

/pst-plantype {
%   args definition
   args (pst-plan-) definition append cvx exec
   dup phi rotateplan
   base length 4 eq {
      dup base planputrange
   } if
   origin eqpl@n pointeqplan 0 eq {
      dup origin planputorigine
   } if
   ngrid length 0 ne {
      dup ngrid planputngrid
   } if
   tx@Dict /solidname known {
      solidname cvlit exch bind def
      tx@Dict /solidname undef
   } {
      pop
   } ifelse
} def
/pst-plan- {pst-plan-plantype} def

%x0 y0 z0 [normalvect] norm2plan
/pst-plan-plantype {
   dup plan2eq /eqpl@n exch def
   /plan-@k true def
} def

/pst-plan {
%   args definition
   args (pst-plan-) definition append cvx exec
   /pl@n-en-cours true def
   definition length 0 ne {
%   plan-@k not {
      dup
      base 0 get base 1 get lt
      base 2 get base 3 get lt and {
         base
      } {
         [-3 3 -2 2] %pop base %aload pop boum
      } ifelse
      planputrange
      origin eqpl@n pointeqplan 0 eq {
         dup origin planputorigine
      } if
      CX isreal
      CX 0 eq and
      CY isreal and
      CY 0 eq and
      CZ isreal and
      CZ 0 eq and not {
         dup CX CY CZ planputorigine
      } if
      /CX 0. def
      /CY 0. def
      /CZ 0. def
      ngrid length 0 ne {
         dup ngrid planputngrid
      } if
   } if
%   dup RotX RotY RotZ rotateOplan
   dup phi rotateplan
   /l@pl@n exch def
   tx@Dict /solidname known {
      l@pl@n solidname cvlit exch bind def
      /solidname solidname (_s) append store
   } if
   l@pl@n newplan
   gere_pstricks_opt
   /pl@n-en-cours false def
%   action ==
%   noir
   l@pl@n RotX RotY RotZ rotateOplan
%   l@pl@n CX CY CZ plantranslate
   fontsize setfontsize
   setTimes
   solidplanmarks {l@pl@n projectionsifacevisible planmarks} if
   solidplangrid {linecolor l@pl@n projectionsifacevisible planquadrillage} if
   solidshowbase {l@pl@n projectionsifacevisible planshowbase} if
   solidshowbase3d {l@pl@n projectionsifacevisible planshowbase3d} if
} def


/pst-plan-normalpoint {
   /plan-@k false def
   norm2plan
   dup plan2eq /eqpl@n exch def
} def

/pst-plan-equation {
   /plan-@k false def
   dup isarray {
      dup /eqpl@n exch def
   } {
      2 copy pop /eqpl@n exch def
   } ifelse
   eq2plan 
} def

/pst-plan-solidface {
   /plan-@k false def
   solidface2plan
   CX isreal
   CX 0 eq and
   CY isreal and
   CY 0 eq and
   CZ isreal and
   CZ 0 eq and not {
      dup CX CY CZ planputorigine
   } if
   
%   dup plangetrange aload pop boum
%   dup origin planputorigine
   dup plan2eq /eqpl@n exch def
} def

/pst-geode {
   ngrid aload pop newgeode
   gere_pstricks_opt
} def

/pst-load {
   solidloadname 
%   /activationgestioncouleurs false def
   gere_pstricks_opt
} def

/pst-point {
gsave
   fontsize setfontsize
   setTimes
   linecolor
   action (none) eqstring not {
      args definition cvx exec point3d
   } if
   texte args definition cvx exec pos (text3d) append cvx exec
   tx@Dict /solidname known {
      texte args definition cvx exec
      solidname cvlit defpoint3d
      tx@Dict /solidname undef
   } if
grestore
} def

%% syntaxe : alpha beta r h newpie --> solid
/pst-pie {
   phi theta r h 
   ngrid length 2 ge {
      [ngrid 0 get ngrid 1 get]
   } if
   newpie
   gere_pstricks_opt
} def

/pst-trigospherique {
3 dict begin
gsave
   solidlinewidth setlinewidth
   linecolor
   linestyle
   args definition cvx exec
grestore
end
} def

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%         procedures pour \psProjection              %%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

/gere_pstricks_proj_opt {
      /planprojpst where {
         pop
         planprojpst projectionsifacevisible projpath
%        /planprojpst where pop /planprojpst undef
      } {
         /solidprojname where {
            /solidprojname get noface phi  
            xorigine 0 eq
            yorigine 0 eq and
            zorigine 0 eq and 
            xorigine isinteger not and
            yorigine isinteger not and
            yorigine isinteger not and {
            } {
               [xorigine yorigine zorigine] (                 ) astr2str 
            } ifelse
            projectionsifacevisible solidprojpath
         } {
            xorigine yorigine zorigine [ normale ] projectionsifacevisible planprojpath
         } ifelse
      } ifelse
} def

/proj-pst-chemin {
   solidlinewidth setlinewidth
   1 dict begin
   newpath
      /cercle {cercle_} def
      path
      linecolor
      gere_pstricks_proj_opt
   end
} def

/proj-pst-courbeR2 {
   l@pl@n plangetrange aload pop 
   setyrange setxrange
   newpath
      xmin ymin l@pl@n pointplan smoveto
      xmin ymax l@pl@n pointplan slineto
      xmax ymax l@pl@n pointplan slineto
      xmax ymin l@pl@n pointplan slineto
      xmin ymin l@pl@n pointplan slineto
      planprojpst projpath
   clip
   solidlinewidth setlinewidth
   newpath
      linecolor
      range aload pop { function cvx exec } CourbeR2_
      gere_pstricks_proj_opt
} def

/proj-pst-courbe {
   l@pl@n plangetrange aload pop 
   setyrange setxrange
   newpath
      xmin ymin l@pl@n pointplan smoveto
      xmin ymax l@pl@n pointplan slineto
      xmax ymax l@pl@n pointplan slineto
      xmax ymin l@pl@n pointplan slineto
      xmin ymin l@pl@n pointplan slineto
      planprojpst projpath
   clip
   solidlinewidth setlinewidth
   newpath
      linecolor
      range aload pop {} { function cvx exec } Courbeparam_
      gere_pstricks_proj_opt
} def

/proj-pst-point {
   [proj-args] length 0 eq {
      xorigine yorigine /proj-args defpoint
   } if
   /projname where {
      pop
      [proj-args proj-definition cvx exec]
      dup 0 getp projname cvlit defpoint
      dup length 2 gt {
         1 getp projname (0) append cvlit defpoint
      } if
      /projname where pop /projname undef
   } if
   proj-action (none) eqstring not {
      solidlinewidth setlinewidth
      linecolor
      [proj-args proj-definition cvx exec] 0 getp point_
      gere_pstricks_proj_opt
      Stroke
   } if
%   1 1 0 0 1 1 Diamond
   texte length 0 gt {
      proj-fontsize setfontsize
      setTimes 
      solidlinewidth setlinewidth
      newpath
      linecolor
      texte [proj-args proj-definition cvx exec 0 0 phi neg rotatepoint] 0 getp 
      pos (text_) append cvx exec
%%    /planprojpst where {
%%       planprojpst dupplan dup phi rotateplan /planprojpst exch def
%%       pop
%%       xorigine yorigine
%%       0 0 phi neg rotatepoint
%%    } {
%%       0 0
%%    } ifelse
      %gere_pstricks_proj_opt
      planprojpst dupplan dup phi rotateplan projectionsifacevisible projpath
      Fill
   } if
} def

/proj-pst-vecteur {
   proj-action (none) eqstring not {
      planprojpst bprojscene
      solidlinewidth setlinewidth
      linestyle
      linecolor
      xorigine yorigine 2 copy proj-args proj-definition cvx exec addv drawvecteur
      eprojscene
   } if
   /projname where {
      pop
      proj-args proj-definition cvx exec projname cvlit defpoint
      /projname where pop /projname undef
   } if
} def

/proj-pst-droite {
   proj-action (none) eqstring not {
      l@pl@n plangetrange aload pop 
      setyrange setxrange
%%       newpath
%%          xmin ymin l@pl@n pointplan smoveto
%%          xmin ymax l@pl@n pointplan slineto
%%          xmax ymax l@pl@n pointplan slineto
%%          xmax ymin l@pl@n pointplan slineto
%%          xmin ymin l@pl@n pointplan smoveto
%%       planprojpst projpath
%%       clip
      planprojpst bprojscene
      solidlinewidth setlinewidth
      linestyle
      linecolor
      proj-args proj-definition cvx exec droite
      eprojscene
   } if
   /projname where {
      pop
      proj-args proj-definition cvx exec projname cvlit defdroite
      /projname where pop /projname undef
   } if
} def

/proj-pst-polygone {
   proj-action (none) eqstring not {
      l@pl@n plangetrange aload pop 
      setyrange setxrange
      newpath
         xmin ymin l@pl@n pointplan smoveto
         xmin ymax l@pl@n pointplan slineto
         xmax ymax l@pl@n pointplan slineto
         xmax ymin l@pl@n pointplan slineto
         xmin ymin l@pl@n pointplan slineto
         planprojpst projpath
      clip
      solidlinewidth setlinewidth
      linestyle
      linecolor
      proj-definition length 0 eq {
         [proj-args]
      } {
         proj-args 
      } ifelse
      proj-definition cvx exec polygone_
      planprojpst projectionsifacevisible projpath
   } if
   /projname where {
      pop
      proj-definition length 0 eq {
         [proj-args]
      } {
         proj-args 
      } ifelse
      proj-definition cvx exec projname cvlit exch def
      /projname where pop /projname undef
   } if
} def

/proj-pst-cercle {
   /projname where {
      pop
      proj-args proj-definition cvx exec projname cvlit defcercle
      /projname where pop /projname undef
   } if
   proj-action (none) eqstring not {
      l@pl@n plangetrange aload pop 
      setyrange setxrange
      newpath
         xmin ymin l@pl@n pointplan smoveto
         xmin ymax l@pl@n pointplan slineto
         xmax ymax l@pl@n pointplan slineto
         xmax ymin l@pl@n pointplan slineto
         xmin ymin l@pl@n pointplan slineto
         planprojpst projpath
      clip
      solidlinewidth setlinewidth
      linestyle
      linecolor
      newpath
      range aload pop proj-args
      proj-definition cvx exec Cercle_
      planprojpst projectionsifacevisible projpath
   } if
} def

/proj-pst-line {
   proj-action (none) eqstring not {
      l@pl@n plangetrange aload pop 
      setyrange setxrange
      newpath
         xmin ymin l@pl@n pointplan smoveto
         xmin ymax l@pl@n pointplan slineto
         xmax ymax l@pl@n pointplan slineto
         xmax ymin l@pl@n pointplan slineto
         xmin ymin l@pl@n pointplan slineto
         planprojpst projpath
      clip
      planprojpst bprojscene
      solidlinewidth setlinewidth
      linestyle
      linecolor
      proj-definition length 0 eq {
         [proj-args]
      } {
         proj-args 
      } ifelse
      proj-definition cvx exec ligne
      eprojscene
   } if
   /projname where {
      pop
      proj-definition length 0 eq {
         [proj-args]
      } {
         proj-args 
      } ifelse
      proj-definition cvx exec projname cvlit exch def
      /projname where pop /projname undef
   } if
} def

/proj-pst-rightangle {
   proj-action (none) eqstring not {
      planprojpst bprojscene
      solidlinewidth setlinewidth
      linestyle
      linecolor
      proj-args proj-definition cvx exec angledroit
      eprojscene
   } if
} def

/proj-pst-texte {
2 dict begin
   proj-fontsize setfontsize
   setTimes 
   solidlinewidth setlinewidth
   newpath
   linecolor
   texte 
   /planprojpst where {
      planprojpst dupplan dup phi rotateplan /planprojpst exch def
      pop
      xorigine yorigine
      0 0 phi neg rotatepoint
   } {
      0 0
   } ifelse
   pos (text_) append cvx exec
   gere_pstricks_proj_opt
Fill
end
} def

% END solides.pro

%%EndProcSet
%%BeginProcSet: cm-super-t1.enc 0 0
% This file is generated from `T1uni.map' and `glyphlist.txt', `gl-other.txt'
%
% LIGKERN hyphen hyphen =: endash ; endash hyphen =: emdash ;
% LIGKERN quoteleft quoteleft =: quotedblleft ;
% LIGKERN quoteright quoteright =: quotedblright ;
% LIGKERN comma comma =: quotedblbase ; less less =: guillemotleft ;
% LIGKERN greater greater =: guillemotright ;
% LIGKERN f f =: ff ; f i =: fi ; f l =: fl ; ff i =: ffi ; ff l =: ffl ;
%
% LIGKERN space {} * ; * {} space ; zero {} * ; * {} zero ;
% LIGKERN one {} * ; * {} one ; two {} * ; * {} two ;
% LIGKERN three {} * ; * {} three ; four {} * ; * {} four ;
% LIGKERN five {} * ; * {} five ; six {} * ; * {} six ;
% LIGKERN seven {} * ; * {} seven ; eight {} * ; * {} eight ;
% LIGKERN nine {} * ; * {} nine ;
%
/T1Encoding [
% 0x00
/grave
/acute
/circumflex
/tilde
/dieresis
/hungarumlaut
/ring
/caron
/breve
/macron
/dotaccent
/cedilla
/ogonek
/quotesinglbase
/guilsinglleft
/guilsinglright
% 0x10
/quotedblleft
/quotedblright
/quotedblbase
/guillemotleft
/guillemotright
/endash
/emdash
/afii61664
/perthousandzero % PERTHOUSAND ZERO
/dotlessi
/dotlessj
/ff
/fi
/fl
/ffi
/ffl
% 0x20
/uni2423
/exclam
/quotedbl
/numbersign
/dollar
/percent
/ampersand
/quoteright
/parenleft
/parenright
/asterisk
/plus
/comma
/hyphen
/period
/slash
% 0x30
/zero
/one
/two
/three
/four
/five
/six
/seven
/eight
/nine
/colon
/semicolon
/less
/equal
/greater
/question
% 0x40
/at
/A
/B
/C
/D
/E
/F
/G
/H
/I
/J
/K
/L
/M
/N
/O
% 0x50
/P
/Q
/R
/S
/T
/U
/V
/W
/X
/Y
/Z
/bracketleft
/backslash
/bracketright
/asciicircum
/underscore
% 0x60
/quoteleft
/a
/b
/c
/d
/e
/f
/g
/h
/i
/j
/k
/l
/m
/n
/o
% 0x70
/p
/q
/r
/s
/t
/u
/v
/w
/x
/y
/z
/braceleft
/bar
/braceright
/asciitilde
/hyphen.alt % HANGING HYPHEN
% 0x80
/Abreve
/Aogonek
/Cacute
/Ccaron
/Dcaron
/Ecaron
/Eogonek
/Gbreve
/Lacute
/Lcaron
/Lslash
/Nacute
/Ncaron
/Eng
/Ohungarumlaut
/Racute
% 0x90
/Rcaron
/Sacute
/Scaron
/Scedilla
/Tcaron
/Tcommaaccent
/Uhungarumlaut
/Uring
/Ydieresis
/Zacute
/Zcaron
/Zdotaccent
/IJ
/Idotaccent
/dcroat
/section
% 0xA0
/abreve
/aogonek
/cacute
/ccaron
/dcaron
/ecaron
/eogonek
/gbreve
/lacute
/lcaron
/lslash
/nacute
/ncaron
/eng
/ohungarumlaut
/racute
% 0xB0
/rcaron
/sacute
/scaron
/scedilla
/tcaron
/tcommaaccent
/uhungarumlaut
/uring
/ydieresis
/zacute
/zcaron
/zdotaccent
/ij
/exclamdown
/questiondown
/sterling
% 0xC0
/Agrave
/Aacute
/Acircumflex
/Atilde
/Adieresis
/Aring
/AE
/Ccedilla
/Egrave
/Eacute
/Ecircumflex
/Edieresis
/Igrave
/Iacute
/Icircumflex
/Idieresis
% 0xD0
/Eth
/Ntilde
/Ograve
/Oacute
/Ocircumflex
/Otilde
/Odieresis
/OE
/Oslash
/Ugrave
/Uacute
/Ucircumflex
/Udieresis
/Yacute
/Thorn
/SS % Germandbls
% 0xE0
/agrave
/aacute
/acircumflex
/atilde
/adieresis
/aring
/ae
/ccedilla
/egrave
/eacute
/ecircumflex
/edieresis
/igrave
/iacute
/icircumflex
/idieresis
% 0xF0
/eth
/ntilde
/ograve
/oacute
/ocircumflex
/otilde
/odieresis
/oe
/oslash
/ugrave
/uacute
/ucircumflex
/udieresis
/yacute
/thorn
/germandbls % or /germandbls.alt
] def

%%EndProcSet
%%BeginProcSet: texps.pro 0 0
%!
TeXDict begin/rf{findfont dup length 1 add dict begin{1 index/FID ne 2
index/UniqueID ne and{def}{pop pop}ifelse}forall[1 index 0 6 -1 roll
exec 0 exch 5 -1 roll VResolution Resolution div mul neg 0 0]FontType 0
ne{/Metrics exch def dict begin Encoding{exch dup type/integertype ne{
pop pop 1 sub dup 0 le{pop}{[}ifelse}{FontMatrix 0 get div Metrics 0 get
div def}ifelse}forall Metrics/Metrics currentdict end def}{{1 index type
/nametype eq{exit}if exch pop}loop}ifelse[2 index currentdict end
definefont 3 -1 roll makefont/setfont cvx]cvx def}def/ObliqueSlant{dup
sin S cos div neg}B/SlantFont{4 index mul add}def/ExtendFont{3 -1 roll
mul exch}def/ReEncodeFont{CharStrings rcheck{/Encoding false def dup[
exch{dup CharStrings exch known not{pop/.notdef/Encoding true def}if}
forall Encoding{]exch pop}{cleartomark}ifelse}if/Encoding exch def}def
end

%%EndProcSet
%%BeginProcSet: special.pro 0 0
%!
TeXDict begin/SDict 200 dict N SDict begin/@SpecialDefaults{/hs 612 N
/vs 792 N/ho 0 N/vo 0 N/hsc 1 N/vsc 1 N/ang 0 N/CLIP 0 N/rwiSeen false N
/rhiSeen false N/letter{}N/note{}N/a4{}N/legal{}N}B/@scaleunit 100 N
/@hscale{@scaleunit div/hsc X}B/@vscale{@scaleunit div/vsc X}B/@hsize{
/hs X/CLIP 1 N}B/@vsize{/vs X/CLIP 1 N}B/@clip{/CLIP 2 N}B/@hoffset{/ho
X}B/@voffset{/vo X}B/@angle{/ang X}B/@rwi{10 div/rwi X/rwiSeen true N}B
/@rhi{10 div/rhi X/rhiSeen true N}B/@llx{/llx X}B/@lly{/lly X}B/@urx{
/urx X}B/@ury{/ury X}B/magscale true def end/@MacSetUp{userdict/md known
{userdict/md get type/dicttype eq{userdict begin md length 10 add md
maxlength ge{/md md dup length 20 add dict copy def}if end md begin
/letter{}N/note{}N/legal{}N/od{txpose 1 0 mtx defaultmatrix dtransform S
atan/pa X newpath clippath mark{transform{itransform moveto}}{transform{
itransform lineto}}{6 -2 roll transform 6 -2 roll transform 6 -2 roll
transform{itransform 6 2 roll itransform 6 2 roll itransform 6 2 roll
curveto}}{{closepath}}pathforall newpath counttomark array astore/gc xdf
pop ct 39 0 put 10 fz 0 fs 2 F/|______Courier fnt invertflag{PaintBlack}
if}N/txpose{pxs pys scale ppr aload pop por{noflips{pop S neg S TR pop 1
-1 scale}if xflip yflip and{pop S neg S TR 180 rotate 1 -1 scale ppr 3
get ppr 1 get neg sub neg ppr 2 get ppr 0 get neg sub neg TR}if xflip
yflip not and{pop S neg S TR pop 180 rotate ppr 3 get ppr 1 get neg sub
neg 0 TR}if yflip xflip not and{ppr 1 get neg ppr 0 get neg TR}if}{
noflips{TR pop pop 270 rotate 1 -1 scale}if xflip yflip and{TR pop pop
90 rotate 1 -1 scale ppr 3 get ppr 1 get neg sub neg ppr 2 get ppr 0 get
neg sub neg TR}if xflip yflip not and{TR pop pop 90 rotate ppr 3 get ppr
1 get neg sub neg 0 TR}if yflip xflip not and{TR pop pop 270 rotate ppr
2 get ppr 0 get neg sub neg 0 S TR}if}ifelse scaleby96{ppr aload pop 4
-1 roll add 2 div 3 1 roll add 2 div 2 copy TR .96 dup scale neg S neg S
TR}if}N/cp{pop pop showpage pm restore}N end}if}if}N/normalscale{
Resolution 72 div VResolution 72 div neg scale magscale{DVImag dup scale
}if 0 setgray}N/psfts{S 65781.76 div N}N/startTexFig{/psf$SavedState
save N userdict maxlength dict begin/magscale true def normalscale
currentpoint TR/psf$ury psfts/psf$urx psfts/psf$lly psfts/psf$llx psfts
/psf$y psfts/psf$x psfts currentpoint/psf$cy X/psf$cx X/psf$sx psf$x
psf$urx psf$llx sub div N/psf$sy psf$y psf$ury psf$lly sub div N psf$sx
psf$sy scale psf$cx psf$sx div psf$llx sub psf$cy psf$sy div psf$ury sub
TR/showpage{}N/erasepage{}N/setpagedevice{pop}N/copypage{}N/p 3 def
@MacSetUp}N/doclip{psf$llx psf$lly psf$urx psf$ury currentpoint 6 2 roll
newpath 4 copy 4 2 roll moveto 6 -1 roll S lineto S lineto S lineto
closepath clip newpath moveto}N/endTexFig{end psf$SavedState restore}N
/@beginspecial{SDict begin/SpecialSave save N gsave normalscale
currentpoint TR @SpecialDefaults count/ocount X/dcount countdictstack N}
N/@setspecial{CLIP 1 eq{newpath 0 0 moveto hs 0 rlineto 0 vs rlineto hs
neg 0 rlineto closepath clip}if ho vo TR hsc vsc scale ang rotate
rwiSeen{rwi urx llx sub div rhiSeen{rhi ury lly sub div}{dup}ifelse
scale llx neg lly neg TR}{rhiSeen{rhi ury lly sub div dup scale llx neg
lly neg TR}if}ifelse CLIP 2 eq{newpath llx lly moveto urx lly lineto urx
ury lineto llx ury lineto closepath clip}if/showpage{}N/erasepage{}N
/setpagedevice{pop}N/copypage{}N newpath}N/@endspecial{count ocount sub{
pop}repeat countdictstack dcount sub{end}repeat grestore SpecialSave
restore end}N/@defspecial{SDict begin}N/@fedspecial{end}B/li{lineto}B
/rl{rlineto}B/rc{rcurveto}B/np{/SaveX currentpoint/SaveY X N 1
setlinecap newpath}N/st{stroke SaveX SaveY moveto}N/fil{fill SaveX SaveY
moveto}N/ellipse{/endangle X/startangle X/yrad X/xrad X/savematrix
matrix currentmatrix N TR xrad yrad scale 0 0 1 startangle endangle arc
savematrix setmatrix}N end

%%EndProcSet
%%BeginProcSet: color.pro 0 0
%!
TeXDict begin/setcmykcolor where{pop}{/setcmykcolor{dup 10 eq{pop
setrgbcolor}{1 sub 4 1 roll 3{3 index add neg dup 0 lt{pop 0}if 3 1 roll
}repeat setrgbcolor pop}ifelse}B}ifelse/TeXcolorcmyk{setcmykcolor}def
/TeXcolorrgb{setrgbcolor}def/TeXcolorgrey{setgray}def/TeXcolorgray{
setgray}def/TeXcolorhsb{sethsbcolor}def/currentcmykcolor where{pop}{
/currentcmykcolor{currentrgbcolor 10}B}ifelse/DC{exch dup userdict exch
known{pop pop}{X}ifelse}B/GreenYellow{0.15 0 0.69 0 setcmykcolor}DC
/Yellow{0 0 1 0 setcmykcolor}DC/Goldenrod{0 0.10 0.84 0 setcmykcolor}DC
/Dandelion{0 0.29 0.84 0 setcmykcolor}DC/Apricot{0 0.32 0.52 0
setcmykcolor}DC/Peach{0 0.50 0.70 0 setcmykcolor}DC/Melon{0 0.46 0.50 0
setcmykcolor}DC/YellowOrange{0 0.42 1 0 setcmykcolor}DC/Orange{0 0.61
0.87 0 setcmykcolor}DC/BurntOrange{0 0.51 1 0 setcmykcolor}DC
/Bittersweet{0 0.75 1 0.24 setcmykcolor}DC/RedOrange{0 0.77 0.87 0
setcmykcolor}DC/Mahogany{0 0.85 0.87 0.35 setcmykcolor}DC/Maroon{0 0.87
0.68 0.32 setcmykcolor}DC/BrickRed{0 0.89 0.94 0.28 setcmykcolor}DC/Red{
0 1 1 0 setcmykcolor}DC/OrangeRed{0 1 0.50 0 setcmykcolor}DC/RubineRed{
0 1 0.13 0 setcmykcolor}DC/WildStrawberry{0 0.96 0.39 0 setcmykcolor}DC
/Salmon{0 0.53 0.38 0 setcmykcolor}DC/CarnationPink{0 0.63 0 0
setcmykcolor}DC/Magenta{0 1 0 0 setcmykcolor}DC/VioletRed{0 0.81 0 0
setcmykcolor}DC/Rhodamine{0 0.82 0 0 setcmykcolor}DC/Mulberry{0.34 0.90
0 0.02 setcmykcolor}DC/RedViolet{0.07 0.90 0 0.34 setcmykcolor}DC
/Fuchsia{0.47 0.91 0 0.08 setcmykcolor}DC/Lavender{0 0.48 0 0
setcmykcolor}DC/Thistle{0.12 0.59 0 0 setcmykcolor}DC/Orchid{0.32 0.64 0
0 setcmykcolor}DC/DarkOrchid{0.40 0.80 0.20 0 setcmykcolor}DC/Purple{
0.45 0.86 0 0 setcmykcolor}DC/Plum{0.50 1 0 0 setcmykcolor}DC/Violet{
0.79 0.88 0 0 setcmykcolor}DC/RoyalPurple{0.75 0.90 0 0 setcmykcolor}DC
/BlueViolet{0.86 0.91 0 0.04 setcmykcolor}DC/Periwinkle{0.57 0.55 0 0
setcmykcolor}DC/CadetBlue{0.62 0.57 0.23 0 setcmykcolor}DC
/CornflowerBlue{0.65 0.13 0 0 setcmykcolor}DC/MidnightBlue{0.98 0.13 0
0.43 setcmykcolor}DC/NavyBlue{0.94 0.54 0 0 setcmykcolor}DC/RoyalBlue{1
0.50 0 0 setcmykcolor}DC/Blue{1 1 0 0 setcmykcolor}DC/Cerulean{0.94 0.11
0 0 setcmykcolor}DC/Cyan{1 0 0 0 setcmykcolor}DC/ProcessBlue{0.96 0 0 0
setcmykcolor}DC/SkyBlue{0.62 0 0.12 0 setcmykcolor}DC/Turquoise{0.85 0
0.20 0 setcmykcolor}DC/TealBlue{0.86 0 0.34 0.02 setcmykcolor}DC
/Aquamarine{0.82 0 0.30 0 setcmykcolor}DC/BlueGreen{0.85 0 0.33 0
setcmykcolor}DC/Emerald{1 0 0.50 0 setcmykcolor}DC/JungleGreen{0.99 0
0.52 0 setcmykcolor}DC/SeaGreen{0.69 0 0.50 0 setcmykcolor}DC/Green{1 0
1 0 setcmykcolor}DC/ForestGreen{0.91 0 0.88 0.12 setcmykcolor}DC
/PineGreen{0.92 0 0.59 0.25 setcmykcolor}DC/LimeGreen{0.50 0 1 0
setcmykcolor}DC/YellowGreen{0.44 0 0.74 0 setcmykcolor}DC/SpringGreen{
0.26 0 0.76 0 setcmykcolor}DC/OliveGreen{0.64 0 0.95 0.40 setcmykcolor}
DC/RawSienna{0 0.72 1 0.45 setcmykcolor}DC/Sepia{0 0.83 1 0.70
setcmykcolor}DC/Brown{0 0.81 1 0.60 setcmykcolor}DC/Tan{0.14 0.42 0.56 0
setcmykcolor}DC/Gray{0 0 0 0.50 setcmykcolor}DC/Black{0 0 0 1
setcmykcolor}DC/White{0 0 0 0 setcmykcolor}DC end

%%EndProcSet
%%BeginFont: SFRM1000
%!FontType1-1.0: SFRM1000 0.3
%%CreationDate: Wed Sep 12 2001
% Copyright (c) 2001 Vladimir Volovich <vvv@vsu.ru>.
% See the file COPYING (GNU General Public License) for license conditions.
% Converted from METAFONT EC/TC and LH fonts:
% ecrm1000, tcrm1000, larm1000, lbrm1000, lcrm1000, rxrm1000.
11 dict begin
/FontInfo 6 dict dup begin
/version (0.3) def
/FullName (Computer Modern Roman) def
/FamilyName (Computer Modern) def
/ItalicAngle 0 def
/isFixedPitch false def
/Weight (Medium) def
end readonly def
/FontName /SFRM1000 def
/Encoding StandardEncoding def
/PaintType 0 def
/FontType 1 def
/FontMatrix [0.001 0 0 0.001 0 0] def
/FontBBox{-189 -321 1456 937}readonly def
currentdict end
currentfile eexec
D9D66F633B846A97B686A97E45A3D0AA052A014267B7904EB3C0D3BD0B83D891
016CA6B55C6E47AD7A9A958A6E22E00FDD4D6492D53ADDC90ECD778346C06747
57609FE8907DFFFED75E2CF963A64C7F72488F4A02372BE681E9BBF09A9CE5A9
3894F6358C244FCD46C148F1EB60DE2137E6D3079D6AE03B3724F7D7BBA47BC4
41C27FFFDFF9FB7B7738A8D88C27573A53E244723E07C995948DED2516B6044E
ADED62C496A56BC14483D307884467ADE985655A4712DD06ED00811F9A05BF9F
BF2AC66203817289FFB5BDCD0445293981AF6F55928C132E885ED009DE1B5FB0
C230370EB5156A8B609E466F00F768F0A52ABCFBFCE3514C0FDDE31E601AD508
2666AD26D9DB386B9FEC80AC197C9FE7447928C0C6A2858375F0A1D7AD3BE53C
9A926DDFBAC60D846783AA97CB86F804701BF53F7C4D18B925FD604F60231215
EBDF4FAD73F2D13518E1901C3DA00ACE65647765106EFCA89D1CE17ADBB75815
7BF819C45DA64CEAA10062501C3B0FE0387FD5406CBDB17A69376AFED2632E2A
C400D16CA3657327EBBCF7CAC55A62AC9AB3D07691C97D98ABFA2A4C85DB2345
C8773110004A7812B031AB3F9B3AB9C7D0E5A2317931334466110BC5C95CE00C
E1CD16242B71CCB962978DB5B8FB03BB2FED25589D10F8B3861F73DAEE17BC59
B909B17D2510F640D341330CCF08ADF9E3106B0C8BB0D04D5F939FAE21AFE501
4614CBFE82CAEF30ECC2B6B47B373FAB1A828AA3CDF7B59BF013442EEFE267AA
AF153EE99EBE4743CA764DA09185666446630553F3D278E1953BFF08FE477C68
4661A47656EC28B2039365CA017F4F1B6E9F85525565795336F7137CD6A3B915
8DE385C64EDA6B73D489FB7338C23DBE575E588D42B0EE3DB6FBE29CC460BCFF
2CD1B7CE1F259C7CC696E94019AD3E8183EA4A4525499ABBCB06ED61E8A86A8A
7D19918F0464D56D7C7D75085EE53E1A7E6216471473E77E4901277294AE262E
5A97692DB5BA38CA0076B6F4989B3FD5F350F66484E3AD84FFA53803A1F58968
0866CC1AC68E6F645C27A233AAEADA7A412C7D3B5264952A58F7F7615C6A17F6
471485C60607EB281BBBC65460660B90B1BBEEC0AF1A50754FD941C2E88135AE
30195934CA89869D420A6BE98B492BCECE484A55E0557A2D6FA9C40313FAB7EB
99FD04C2959AEE5D59A44EFA71313EF1C4F1E479C02EF08F614BBB421B54B89F
3064A82E89500DA311DF77D9CAE81E58E287BE516AB15FA7F4FBA621F4F90F15
DA162F56664AA594B81273331DBAA2475604BC0F2A13AC1911E23D60CE399FEB
1319BF88B2396DBC7A0CDC15FAC9E0C0F0E7F1B96B0FE2C76D37BD4A38F3659E
4856CB453A783846E199E049A580674100049BED20A5E825997B66CAA56436FD
01E2EF83A37E21CCE83AE1102EC3A99442A63BCF80AE21F5CF2807B77EEE3879
067CD0F020DA7E11834B239EC548D4B89141D8190749ED464DC06C800509497D
15514BBE90E47A17CAC50BB75B7A22FB16072CEE88E0257EDACFB176757ACC94
9C1BDEB937270E42A166741048A5C0F67B7D199DC3D2EC1893
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
cleartomark
%%EndFont 
%%BeginFont: SFBX1440
%!FontType1-1.0: SFBX1440 0.3
%%CreationDate: Wed Sep 12 2001
% Copyright (c) 2001 Vladimir Volovich <vvv@vsu.ru>.
% See the file COPYING (GNU General Public License) for license conditions.
% Converted from METAFONT EC/TC and LH fonts:
% ecbx1440, tcbx1440, labx1440, lbbx1440, lcbx1440, rxbx1440.
11 dict begin
/FontInfo 6 dict dup begin
/version (0.3) def
/FullName (Computer Modern Bold Extended) def
/FamilyName (Computer Modern) def
/ItalicAngle 0 def
/isFixedPitch false def
/Weight (Bold) def
end readonly def
/FontName /SFBX1440 def
/Encoding StandardEncoding def
/PaintType 0 def
/FontType 1 def
/FontMatrix [0.001 0 0 0.001 0 0] def
/FontBBox{-218 -316 1652 915}readonly def
currentdict end
currentfile eexec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0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
cleartomark
%%EndFont 
%%BeginFont: SFRM1200
%!FontType1-1.0: SFRM1200 0.3
%%CreationDate: Wed Sep 12 2001
% Copyright (c) 2001 Vladimir Volovich <vvv@vsu.ru>.
% See the file COPYING (GNU General Public License) for license conditions.
% Converted from METAFONT EC/TC and LH fonts:
% ecrm1200, tcrm1200, larm1200, lbrm1200, lcrm1200, rxrm1200.
11 dict begin
/FontInfo 6 dict dup begin
/version (0.3) def
/FullName (Computer Modern Roman) def
/FamilyName (Computer Modern) def
/ItalicAngle 0 def
/isFixedPitch false def
/Weight (Medium) def
end readonly def
/FontName /SFRM1200 def
/Encoding StandardEncoding def
/PaintType 0 def
/FontType 1 def
/FontMatrix [0.001 0 0 0.001 0 0] def
/FontBBox{-185 -320 1420 942}readonly def
currentdict end
currentfile eexec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0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
cleartomark
%%EndFont 
%%BeginFont: SFRM1728
%!FontType1-1.0: SFRM1728 0.3
%%CreationDate: Wed Sep 12 2001
% Copyright (c) 2001 Vladimir Volovich <vvv@vsu.ru>.
% See the file COPYING (GNU General Public License) for license conditions.
% Converted from METAFONT EC/TC and LH fonts:
% ecrm1728, tcrm1728, larm1728, lbrm1728, lcrm1728, rxrm1728.
11 dict begin
/FontInfo 6 dict dup begin
/version (0.3) def
/FullName (Computer Modern Roman) def
/FamilyName (Computer Modern) def
/ItalicAngle 0 def
/isFixedPitch false def
/Weight (Medium) def
end readonly def
/FontName /SFRM1728 def
/Encoding StandardEncoding def
/PaintType 0 def
/FontType 1 def
/FontMatrix [0.001 0 0 0.001 0 0] def
/FontBBox{-174 -318 1347 949}readonly def
currentdict end
currentfile eexec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0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
cleartomark
%%EndFont 
%%BeginFont: SFTT1728
%!FontType1-1.0: SFTT1728 0.3
%%CreationDate: Wed Sep 12 2001
% Copyright (c) 2001 Vladimir Volovich <vvv@vsu.ru>.
% See the file COPYING (GNU General Public License) for license conditions.
% Converted from METAFONT EC/TC and LH fonts:
% ectt1728, tctt1728, latt1728, lbtt1728, lctt1728, rxtt1728.
11 dict begin
/FontInfo 6 dict dup begin
/version (0.3) def
/FullName (Computer Modern Typewriter) def
/FamilyName (Computer Modern) def
/ItalicAngle 0 def
/isFixedPitch true def
/Weight (Medium) def
end readonly def
/FontName /SFTT1728 def
/Encoding StandardEncoding def
/PaintType 0 def
/FontType 1 def
/FontMatrix [0.001 0 0 0.001 0 0] def
/FontBBox{-194 -360 1303 830}readonly def
currentdict end
currentfile eexec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0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
cleartomark
%%EndFont 
TeXDict begin 39158280 55380996 1000 600 600 (test_04.dvi)
@start /Fa 205[42 42 49[{T1Encoding ReEncodeFont}2 83.022
/SFRM1000 rf /Fb 22[60 114[69 73 51 52 53 1[73 66 3[69
40 37 73 2[60 73 58 73 66 12[91 73 2[90 29[66 66 20[73
28[{T1Encoding ReEncodeFont}23 119.552 /SFBX1440 rf /Fc
134[51 3[54 8[27 33[50 17[49 4[49 49 49 49 3[27 44[{
T1Encoding ReEncodeFont}10 99.6264 /SFRM1200 rf /Fd 139[52
53 13[60 16[97 25[37 58[{T1Encoding ReEncodeFont}5 143.462
/SFRM1728 rf /Fe 139[72 72 2[72 72 2[72 2[72 3[72 72
48[72 5[72 45[{T1Encoding ReEncodeFont}10 143.462 /SFTT1728
rf end
%%EndProlog
%%BeginSetup
%%Feature: *Resolution 600dpi
TeXDict begin
%%BeginPaperSize: a4
/setpagedevice where
{ pop << /PageSize [595 842] >> setpagedevice }
{ /a4 where { pop a4 } if }
ifelse
%%EndPaperSize
 end
%%EndSetup
%%Page: 1 1
TeXDict begin 1 0 bop 0 TeXcolorgray Black 0 TeXcolorgray
0 TeXcolorgray 0 TeXcolorgray 1371 304 a Fe(pst-solides3d)45
b Fd(:)1755 487 y(T)-11 b(est)1597 922 y Fc(July)33 b(13,)f(2008)144
1280 y Fb(1)131 b(T)-11 b(est)44 b(\351criture)h(de)e(\034c)l(hier)i
(ob)7 b(j)44 b(a)l(v)l(ec)h(jps)p 0 TeXcolorgray 0 TeXcolorgray
581 4464 a
 tx@Dict begin CM STV CP T newpath /a 0.0 def /w 312.98018 a add def
/d 0.0 a add neg def /h 369.88567 a add def a neg d moveto a neg h
L w h L w d L closepath clip newpath 0 0 moveto setmatrix end
 581 4464 a 1762 3520 a @beginspecial @setspecial
  tx@Dict begin STP newpath 0.8 SLW 0  setgray  0. true -142.26372
-113.81097 170.71646 256.07469 .5 Frame  gsave 0.8 SLW 0  setgray 
1. .setopacityalpha  0  setlinecap stroke  grestore end


@endspecial @beginspecial @setspecial
  tx@Dict begin STP newpath 0.8 SLW 0  setgray   1 setlinejoin /pst@fill
{ 1. .setopacityalpha fill } def /strokeopacity 1. def /fillopacity
1. def /xunit {28.45274 } def /decal -2 def /viewpointXYZ {50 -20 30
rtp2xyz} def /Decran 50 def /RotX 0 def /RotY 0 def /RotZ 0 def /fontsize
{10  28.45274 mul 28.45 div } bind def /projectionsifacevisible true
def /R 4 def /r1 4 def /r0 1.5 def /resolution 36 def /phi 0 def /theta
90 def /r 2 def /a 4 def /b a def /c a def /h 6 def /trunccoeff .25
def /chanfreincoeff .8 def /affinagecoeff .8 def /dualregcoeff 1 def
/solidintersectiontype -1 def /section {R h 2 div neg R h 2 div r h
2 div r h 2 div neg } def /base [ -1 -1 1 -1 0 1] def /solidintersectionlinewidth
[ 1] def /solidintersectioncolor [ (rouge)] def /solidintersectionplan
[ [0 0 1 0]] def /axe { 0 0 1} def /plansection [ ] def /definition
() def /args { } def /Mode 2 def /lightintensity 2 def /solidlinewidth
{0.8 } def /linecolor {0  setgray } def /linestyle {solid} def /fillcolor
{1  setgray currentrgbcolor} def /fillincolor {0 1 0  setrgbcolor currentrgbcolor}
def /color1 {1 0 0 0  setcmykcolor } def /color2 {0 1 0 0  setcmykcolor
} def /color3 {0 0 1  setrgbcolor } def /color4 {1 0 0  setrgbcolor
} def /range [ -5 5] def /action (draw**) def /texte () def /pos (cc)
def /proj-fontsize {10  28.45274 mul 28.45 div } bind def /lightsrc
{10 0 10} def /rmfaces [] def /fcol [] def /solidhue [] def /solidinouthue
[] def /solidinhue [] def /origin {0 0 0} def /sommets [] def /faces
[] def /solidshow [] def /solidnum [] def /solidnumf [] def /solidtrunc
[] def /solidaffinage [] def /ngrid [] def /affinagerm true def /chanfrein
false def /solidgrid true def /solidplanmarks false def /solidplangrid
false def /solidshowbase3d false def /activationgestioncouleurs true
def /solidshowbase false def /soliddualreg false def /solidgeode false
def /solidhollow false def /solidbiface true def viewpointXYZ /ZpointVue
ED /YpointVue ED /XpointVue ED /THETA {YpointVue XpointVue atan} bind
def /PHI {ZpointVue XpointVue dup mul YpointVue dup mul add sqrt atan}
bind def /Dobs {XpointVue dup mul YpointVue dup mul add ZpointVue dup
mul add sqrt} bind def XpointVue YpointVue ZpointVue /viewpoint defpoint3d
 SolidesDict begin 0 0 0 /CZ exch def /CY exch def /CX exch def  3
newcube dup (jaune) outputcolors (cube) writeobjfile  end  gsave 0.8
SLW 0  setgray  1. .setopacityalpha  0  setlinecap stroke  grestore
end
 
@endspecial 3180
4464 a
 currentpoint initclip moveto
 3180 4464 a 0 TeXcolorgray 1860 6074 a Fa(1)p
0 TeXcolorgray eop end
%%Page: 2 2
TeXDict begin 2 1 bop 0 TeXcolorgray 0 TeXcolorgray 0
TeXcolorgray 144 -45 a Fb(2)131 b(T)-11 b(est)44 b(\351criture)h(de)e
(\034c)l(hier)i(ob)7 b(j)44 b(a)l(v)l(ec)h(PST)-11 b(ric)l(ks)p
0 TeXcolorgray 0 TeXcolorgray 581 3140 a
 tx@Dict begin CM STV CP T newpath /a 0.0 def /w 312.98018 a add def
/d 0.0 a add neg def /h 369.88567 a add def a neg d moveto a neg h
L w h L w d L closepath clip newpath 0 0 moveto setmatrix end
 581 3140 a 1762
2195 a @beginspecial @setspecial
  tx@Dict begin STP newpath 0.8 SLW 0  setgray  0. true -142.26372
-113.81097 170.71646 256.07469 .5 Frame  gsave 0.8 SLW 0  setgray 
1. .setopacityalpha  0  setlinecap stroke  grestore end
 
@endspecial @beginspecial
@setspecial
  tx@Dict begin STP newpath 0.8 SLW 0  setgray   1 setlinejoin /pst@fill
{ 1. .setopacityalpha fill } def /strokeopacity 1. def /fillopacity
1. def /xunit {28.45274 } def /decal -2 def /viewpointXYZ {50 -20 30
rtp2xyz} def /Decran 50 def /RotX 0 def /RotY 0 def /RotZ 0 def /fontsize
{10  28.45274 mul 28.45 div } bind def /projectionsifacevisible true
def /R 4 def /r1 4 def /r0 1.5 def /resolution 36 def /phi 0 def /theta
90 def /r 2 def /a 4 def /b a def /c a def /h 6 def /trunccoeff .25
def /chanfreincoeff .8 def /affinagecoeff .8 def /dualregcoeff 1 def
/solidintersectiontype -1 def /section {R h 2 div neg R h 2 div r h
2 div r h 2 div neg } def /base [ -1 -1 1 -1 0 1] def /solidintersectionlinewidth
[ 1] def /solidintersectioncolor [ (rouge)] def /solidintersectionplan
[ [0 0 1 0]] def /axe { 0 0 1} def /plansection [ ] def /definition
() def /args { } def /Mode 2 def /lightintensity 2 def /solidlinewidth
{0.8 } def /linecolor {0  setgray } def /linestyle {solid} def /fillcolor
{1  setgray currentrgbcolor} def /fillincolor {0 1 0  setrgbcolor currentrgbcolor}
def /color1 {1 0 0 0  setcmykcolor } def /color2 {0 1 0 0  setcmykcolor
} def /color3 {0 0 1  setrgbcolor } def /color4 {1 0 0  setrgbcolor
} def /range [ -5 5] def /action (writeobj) def /texte () def /pos
(cc) def /proj-fontsize {10  28.45274 mul 28.45 div } bind def /lightsrc
{10 0 10} def /rmfaces [] def /solidfilename (test) def /fcol [] def
/solidhue [] def /solidinouthue [] def /solidinhue [] def /origin {0
0 0} def /sommets [] def /faces [] def /solidshow [] def /solidnum
[] def /solidnumf [] def /solidtrunc [] def /solidaffinage [] def /ngrid
[] def /affinagerm true def /chanfrein false def /solidgrid true def
/solidplanmarks false def /solidplangrid false def /solidshowbase3d
false def /activationgestioncouleurs true def /solidshowbase false
def /soliddualreg false def /solidgeode false def /solidhollow false
def /solidbiface true def viewpointXYZ /ZpointVue ED /YpointVue ED
/XpointVue ED /THETA {YpointVue XpointVue atan} bind def /PHI {ZpointVue
XpointVue dup mul YpointVue dup mul add sqrt atan} bind def /Dobs {XpointVue
dup mul YpointVue dup mul add ZpointVue dup mul add sqrt} bind def
XpointVue YpointVue ZpointVue /viewpoint defpoint3d  SolidesDict begin
0. 0. 0. /CZ exch def /CY exch def /CX exch def pst-cube end  gsave
0.8 SLW 0  setgray  1. .setopacityalpha  0  setlinecap stroke  grestore
end
 
@endspecial 3180 3140 a
 currentpoint initclip moveto
 3180 3140 a 0 TeXcolorgray
1860 6074 a Fa(2)p 0 TeXcolorgray eop end
%%Trailer

userdict /end-hook known{end-hook}if
%%EOF