$SPAD/src/input pasta.input

George L. Legendre and Timothy Daly

December 3, 2016

Abstract

These images and equations are from the book ”Pasty by Design” by George L. Legendre. They are used as test cases for the graphics package. See the fabulous book “Pasta by Design” Thames and Hudson, ISBN 978-0-500-51580-8

Contents

2

— * —

)set break resume
)sys rm -f pasta.output
)spool pasta.output
)set message test on
)set message auto off
)clear all

———-

1 Acini Di Pepe

The smallest member of the postine minute (tiny pasta) family, acini de pepe (peppercorns) are most suited to consommes (clear soups), with the occasional addition of croutons and diced greens. Made of durum wheat flour and eggs, acini di pepe are commonly used in the Italian-American “wedding soup”, a broth of vegetables and meat.

— * —

)clear all
--S 1 of 676
X(i,j) == 15*cos(i/60*%pi)
--R                                                                   Type: Void
--E 1
--S 2 of 676
Y(i,j) == 15*sin(i/60*%pi)
--R                                                                   Type: Void
--E 2
--S 3 of 676
Z(i,y) == j
--R                                                                   Type: Void
--E 3
--S 4 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..120,j=0..30,_
          style=="smooth",title=="Acini Di Pepe")
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Integer
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Integer
--R   Compiling function Z with type (Variable i,Variable j) -> Variable j
--R
--I   Compiling function %A with type (DoubleFloat,DoubleFloat) ->

--R      DoubleFloat
--I   Compiling function %B with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %D with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Acini Di Pepe"
--R                                               Type: ThreeDimensionalViewport
--E 4
--S 5 of 676
close(v3d)
--R                                                                   Type: Void
--E 5

———-

2 Agnolotti

These shell-like ravioli from Piedmont, northern italy, are fashioned from small pieces of flattened dough made of wheat flour and egg, and are often filled with braised veal, port, vegetables or cheese. The true agnolotto should feature a crinkled edge, cut using a fluted pasta wheel. Recommended with melted butter and sage

— * —

)clear all
--S 6 of 676
X(i,j) == (10*sin((i/120)*%pi)^(0.5) + _
           (1/400)*sin(((3*j)/10)*%pi)) * _
          cos(((19*j)/2000)*%pi+0.03*%pi)
--R
--R                                                                   Type: Void
--E 6
--S 7 of 676
Y(i,j) == (10*sin((i/120)*%pi) + _
           (1/400)*cos(((30*j)/10)*%pi)) * _
          sin(((19*j)/2000)*%pi+0.03*%pi)
--R
--R                                                                   Type: Void
--E 7
--S 8 of 676
Z(i,j) == 5*cos((i/120)*%pi)^5 * sin((j/100)*%pi) - _
          5*sin((j/100)*%pi) * cos((i/120)*%pi)^200

--R
--R                                                                   Type: Void
--E 8
--S 9 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..60,j=0..100,_
          style=="smooth",title=="Agnolotti")
--R
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Expression
--R      Integer
--I   Compiling function %EJ with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %EL with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %EN with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Agnolotti"
--R                                               Type: ThreeDimensionalViewport
--E 9
--S 10 of 676
close(v3d)
--R                                                                   Type: Void
--E 10

———-

3 Anellini

The diminutive onellini (small rings) are part of the extended postine minute (tiny pasta) clan. Their thickness varies between only 1.15 and 1.20 mm, and the are therefore usually found in light soups together with croutons and thinly sliced vegetables. This pasta may also be found served in a timballo (baked pasta dish).

— * —

)clear all
--S 11 of 676
X(i,j) == cos(0.01*i*%pi)
--R                                                                   Type: Void
--E 11

--S 12 of 676
Y(i,j) == 1.1*sin(0.01*i*%pi)
--R                                                                   Type: Void
--E 12
--S 13 of 676
Z(i,j) == 0.05*j
--R                                                                   Type: Void
--E 13
--S 14 of 676
canvas := createThreeSpace()
--R
--R   (4)  3-Space with 0 components
--R                                                 Type: ThreeSpace DoubleFloat
--E 14
--S 15 of 676
makeObject(surface(X(i,j),Y(i,j),Z(i,j)),i=0..200,j=0..8,space==canvas)
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Polynomial
--R      Float
--I   Compiling function %T with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %V with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %X with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R
--R   (5)  3-Space with 1 component
--R                                                 Type: ThreeSpace DoubleFloat
--E 15
--S 16 of 676
makeObject(surface(X(i,j)/1.4,Y(i,j)/1.4,Z(i,j)),i=0..200,j=0..8,space==canvas)
--I   Compiling function %Z with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %BB with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %BD with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R
--R   (6)  3-Space with 2 components
--R                                                 Type: ThreeSpace DoubleFloat
--E 16

--S 17 of 676
vp:=makeViewport3D(canvas,"Anellini")
--R   Transmitting data...
--R
--R   (7)  ThreeDimensionalViewport: "Anellini"
--R                                               Type: ThreeDimensionalViewport
--E 17
--S 18 of 676
close(vp)
--R                                                                   Type: Void
--E 18

———-

4 Bucatini

Bucatini (pierced) pasta is commonly served as a pastasciutta (pasta boiled, drained, and dished up with a sauce, rather than in broth). Its best known accompaniment is amatriciana: a hearty traditional sauce made with dried port, Pecorino Romano and tomato sauce, and named after the medieval town of Amatrice in central Italy.

— * —

)clear all
--S 19 of 676
X(i,j) == 0.3*cos(i/30*%pi)
--R                                                                   Type: Void
--E 19
--S 20 of 676
Y(i,j) == 0.3*sin(i/30*%pi)
--R                                                                   Type: Void
--E 20
--S 21 of 676
Z(i,j) == j/45
--R                                                                   Type: Void
--E 21
--S 22 of 676
canvas := createThreeSpace()
--R
--R   (4)  3-Space with 0 components
--R                                                 Type: ThreeSpace DoubleFloat
--E 22

--S 23 of 676
makeObject(surface(X(i,j),Y(i,j),Z(i,j)),i=0..60,j=0..90,space==canvas)
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Polynomial
--R      Fraction Integer
--I   Compiling function %BJ with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %BL with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %BN with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R
--R   (5)  3-Space with 1 component
--R                                                 Type: ThreeSpace DoubleFloat
--E 23
--S 24 of 676
makeObject(surface(X(i,j)/2,Y(i,j)/2,Z(i,j)),i=0..60,j=0..90,space==canvas)
--I   Compiling function %BP with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %BR with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %BT with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R
--R   (6)  3-Space with 2 components
--R                                                 Type: ThreeSpace DoubleFloat
--E 24
--S 25 of 676
vp:=makeViewport3D(canvas,"Bucatini")
--R   Transmitting data...
--R
--R   (7)  ThreeDimensionalViewport: "Bucatini"
--R                                               Type: ThreeDimensionalViewport
--E 25
--S 26 of 676
close(vp)
--R                                                                   Type: Void
--E 26

———-

5 Buccoli

A spiral-shaped example from the pasta corta (short pasta) family, and of rather uncertain pedigree, buccoli are suitable in a mushroom and sausage dish. They are also excellent with a tomato aubergine, pesto, and ricotta salad.

— * —

)clear all
--S 27 of 676
X(i,j) == (0.7 + 0.2*sin(21*j/250 * %pi))*cos(i/20*%pi)
--R                                                                   Type: Void
--E 27
--S 28 of 676
Y(i,j) == (0.7 + 0.2*sin(21*j/250 * %pi))*sin(i/20*%pi)
--R                                                                   Type: Void
--E 28
--S 29 of 676
Z(i,j) == 39.0*i/1000. + 1.5*sin(j/50*%pi)
--R                                                                   Type: Void
--E 29
--S 30 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..200,j=0..25,_
          style=="smooth",title=="Buccoli")
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Expression
--R      Float
--I   Compiling function %BV with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %BX with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %BZ with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Buccoli"
--R                                               Type: ThreeDimensionalViewport
--E 30
--S 31 of 676
close(v3d)
--R                                                                   Type: Void
--E 31

———-

6 Calamaretti

Literally “little squids”, calamaretti are small ring-shaped pasta cooked as pastasciutta (pasta boiled and drained) then dished up with a tomato-, egg-, or cheese-based sauce. Their shape means that calamaretti hold both chunky and thin sauces equally well. Fittingly, they are often served with seafood.

— * —

)clear all
--S 32 of 676
X(i,j) == cos(i/75*%pi) + 0.1*cos(j/40*%pi) + 0.1*cos(i/75*%pi + j/40*%pi)
--R                                                                   Type: Void
--E 32
--S 33 of 676
Y(i,j) == 1.2*sin(i/75*%pi) + 0.2*sin(j/40*%pi)
--R                                                                   Type: Void
--E 33
--S 34 of 676
Z(i,j) == j/10
--R                                                                   Type: Void
--E 34
--S 35 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..150,j=0..20,_
          style=="smooth",title=="Calamaretti")
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Polynomial
--R      Fraction Integer
--I   Compiling function %CH with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %CJ with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %CL with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Calamaretti"
--R                                               Type: ThreeDimensionalViewport

--E 35
--S 36 of 676
close(v3d)
--R                                                                   Type: Void
--E 36

———-

7 Cannelloni

Made with wheat flour, eggs, and olive oil, cannelloni (big tubes) originate as strips of pasta shaped into perfect cylinders, which can be stuffed with meat, vegetables, or ricotta. The stuffed cannelloni are covered with a creamy besciamella sauce, a sprinkling of Parmigiano-Reggiano cheese and then oven-baked.

— * —

)clear all
--S 37 of 676
X(i,j) == (1+j/100)*cos(i*%pi/55) + 0.5*cos(j*%pi/100) + _
          0.1*cos(i*%pi/55+j*%pi/125)
--R
--R                                                                   Type: Void
--E 37
--S 38 of 676
Y(i,j) == 1.3*sin(i*%pi/55) + 0.3*sin(j*%pi/100)
--R
--R                                                                   Type: Void
--E 38
--S 39 of 676
Z(i,j) == 7.*j/50.
--R
--R                                                                   Type: Void
--E 39
--S 40 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..110,j=0..50,_
          style=="smooth",title=="Cannelloni")
--R
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Polynomial
--R      Float

--I   Compiling function %BZ with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %CB with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %CD with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Cannelloni"
--R                                               Type: ThreeDimensionalViewport
--E 40
--S 41 of 676
zoom(v3d,2.0,2.0,2.0)
--R
--R                                                                   Type: Void
--E 41
--S 42 of 676
close(v3d)
--R                                                                   Type: Void
--E 42

———-

8 Cannolicchi Rigati

Known as “little tubes”, cannolicchi exist both in a rigati (grooved) and lisci (smooth) form. These hollow pasta corta (short pasta) come in various diameters and are often served with seafood. Cannolicchi hail from Campania in southern Italy.

— * —

)clear all
--S 43 of 676
X(i,j) == 8*cos(i*%pi/70) + 0.2*cos(2*i*%pi/7) + 5*cos(j*%pi/100)
--R
--R                                                                   Type: Void
--E 43
--S 44 of 676
Y(i,j) == 8*sin(i*%pi/70) + 0.2*sin(2*i*%pi/7) + 4*sin(j*%pi/100)
--R
--R                                                                   Type: Void
--E 44
--S 45 of 676
Z(i,j) == 6.0*j/5.0

--S 46 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..140,j=0..50,_
          style=="smooth",title=="Cannolicchi Rigati")
--R
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Polynomial
--R      Float
--I   Compiling function %CF with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %CH with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %CJ with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Cannolicchi Rigati"
--R                                               Type: ThreeDimensionalViewport
--E 46
--S 47 of 676
zoom(v3d,3.0,3.0,3.0)
--R
--R                                                                   Type: Void
--E 47
--S 48 of 676
close(v3d)
--R                                                                   Type: Void
--E 48

———-

9 Capellini

An extra-fine rod-like pasta capellini (thin hair) may be served in a light broth, but also combine perfectly with butter, nutmeg, or lemon. This variety (or its even more slender relative, capelli d’angelo (angel hair) is sometimes used to form the basis of an unusual sweet pasta dish, made with lemons and almonds, called torta ricciolina.

— * —

)clear all
--S 49 of 676
X(i,j) == 0.05*cos(2*i*%pi/15) + 0.6*cos(j*%pi/100)
--R
--R                                                                   Type: Void
--E 49
--S 50 of 676
Y(i,j) == 0.05*sin(2*i*%pi/15) + 0.5*sin(j*%pi/100)
--R
--R                                                                   Type: Void
--E 50
--S 51 of 676
Z(i,j) == 7.0*j/100.0
--R
--R                                                                   Type: Void
--E 51
--S 52 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..15,j=0..100,_
          style=="smooth",title=="Capellini")
--R
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Polynomial
--R      Float
--I   Compiling function %CL with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %CN with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %CP with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Capellini"
--R                                               Type: ThreeDimensionalViewport
--E 52
--S 53 of 676
zoom(v3d,3.0,3.0,3.0)
--R
--R                                                                   Type: Void
--E 53
--S 54 of 676
close(v3d)

--R                                                                   Type: Void
--E 54

———-

10 Cappelletti

This pasta is customarily served as the first course of a traditional north Italian Christmas meal, dished up in a chicken brodo (broth). Typically, it is the children of a houseold who prepare the cappelletti (little hats) on Christmas Eve, filling the pasta parcels (made from wheat flour and fresh eggs) with mixed meats or soft cheeses, such as ricotta.

— * —

)clear all
--S 55 of 676
X(i,j) == (0.1 + sin(((3*i)/160)*%pi)) * cos(((2.3*j)/120)*%pi)
--R
--R                                                                   Type: Void
--E 55
--S 56 of 676
Y(i,j) == (0.1 + sin(((3*i)/160)*%pi)) * sin(((2.3*j)/120)*%pi)
--R
--R                                                                   Type: Void
--E 56
--S 57 of 676
Z(i,j) == 0.1 + (1/400.)*j + (0.3 - 0.231*(i/40.)) * cos((i/20.)*%pi)
--R
--R                                                                   Type: Void
--E 57
--S 58 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..40,j=0..120,_
          style=="smooth",title=="Cappelletti")
--R
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Expression
--R      Float
--I   Compiling function %EP with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %ER with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %ET with type (DoubleFloat,DoubleFloat) ->

--R      DoubleFloat
--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Cappelletti"
--R                                               Type: ThreeDimensionalViewport
--E 58
--S 59 of 676
close(v3d)
--R                                                                   Type: Void
--E 59

———-

11 Casarecce

Easily identified by their unique s-shaped cross-section casarecce (home-made) are best cooked as postasciutta (pasta boiled, drained and dished up with a sauce). Often casarecce are served with a classic ragu and topped with a sprinkle of pepper and Parmigiano-Reggiano cheese.

— * —

)clear all
--S 60 of 676
X(i,j) == _
  if (i <= 30)_
   then 0.5*cos(j*%pi/30)+0.5*cos((2*i+j+16)/40*%pi) _
   else cos(j*%pi/40)+0.5*cos(j*%pi/30)+0.5*sin((2*i-j)/40*%pi)
--R                                                                   Type: Void
--E 60
--S 61 of 676
Y(i,j) == _
  if (i <= 30)_
   then 0.5*sin(j*%pi/30)+0.5*sin((2*i+j+16)/40*%pi) _
   else sin(j*%pi/40)+0.5*sin(j*%pi/30)+0.5*cos((2*i-j)/40*%pi)
--R                                                                   Type: Void
--E 61
--S 62 of 676
Z(i,j) == j/4.0
--R                                                                   Type: Void
--E 62
--S 63 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..60,j=0..60,_
          style=="smooth",title=="Casarecce")

--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Polynomial
--R      Float
--I   Compiling function %WY with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %XA with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %XC with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R
--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Casarecce"
--R                                               Type: ThreeDimensionalViewport
--E 63
--S 64 of 676
zoom(v3d,3.0,3.0,3.0)
--R                                                                   Type: Void
--E 64
--S 65 of 676
close(v3d)
--R                                                                   Type: Void
--E 65

———-

12 Castellane

The manufacturer Bailla has recently created this elegant pasta shape. Accordking to its maker, they were originally called paguri (hermit crabs) but renamed castellane (castle dwellers). The sturdy form and rich nutty taste of castellane stand up to hearty meals and full-flavoured sauces.

— * —

)clear all
--S 66 of 676
X(i,j) == ((0.3*sin(j*%pi/120)*abs(cos((j+3)*%pi/6)) + _
           i^2/720.*(sin(2*j*%pi/300)^2+0.1) + 0.3)) * cos(7*i*%pi/150)
--R                                                                   Type: Void
--E 66
--S 67 of 676

Y(i,j) == ((0.3*sin(j*%pi/120)*abs(cos((j+3)*%pi/6)) + _
           i^2/720.*(sin(2*j*%pi/300)^2+0.1) + 0.3)) * sin(7*i*%pi/150)
--R                                                                   Type: Void
--E 67
--S 68 of 676
Z(i,j) == 12*cos(j*%pi/120)
--R                                                                   Type: Void
--E 68
--S 69 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..60,j=0..120,_
          style=="smooth",title=="Castellane")
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Expression
--R      Integer
--I   Compiling function %XJ with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %XK with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %XM with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Castellane"
--R                                               Type: ThreeDimensionalViewport
--E 69
--S 70 of 676
viewpoint(v3d,0.0,0.0,45.0)
--R                                                                   Type: Void
--E 70
--S 71 of 676
rotate(v3d,270,30)
--R                                                                   Type: Void
--E 71
--S 72 of 676
zoom(v3d,1.5,1.5,1.5)
--R                                                                   Type: Void
--E 72
--S 73 of 676
close(v3d)
--R                                                                   Type: Void
--E 73

13 Cavatappi

Perfect with chunky sauces made from lamb or pork, cavatappi (corkscrews) are 36 mm-long, hollow helicoidal tubes. As well as an accompaniment to creamy sauces, such as boscaiola (woodsman’s) sauce, they are also often used in oven-baked cheese-topped dishes, or in salads with pesto.

— * —

)clear all
--S 74 of 676
X(i,j) == (3+2*cos(i*%pi/35)+0.1*cos(2*i*%pi/7))*cos(j*%pi/30)
--R                                                                   Type: Void
--E 74
--S 75 of 676
Y(i,j) == (3+2*cos(i*%pi/35)+0.1*cos(2*i*%pi/7))*sin(j*%pi/30)
--R                                                                   Type: Void
--E 75
--S 76 of 676
Z(i,j) == 3+2*sin(i*%pi/35)+0.1*sin(2*i*%pi/7)+j/6.0
--R                                                                   Type: Void
--E 76
--S 77 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..70,j=0..150,_
          style=="smooth",title=="Cavatappi")
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Expression
--R      Float
--I   Compiling function %XO with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %XQ with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %XS with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Cavatappi"
--R                                               Type: ThreeDimensionalViewport
--E 77

--S 78 of 676
zoom(v3d,2.0,2.0,2.0)
--R                                                                   Type: Void
--E 78
--S 79 of 676
close(v3d)
--R                                                                   Type: Void
--E 79

———-

14 Cavatelli

Popular in the south of Italy, and related in shape to the longer twisted casareccia, cavatelli can be served alla puttanesca (with a sauce containing chilli, garlic, capers, and anchovies). They can also be added to a salad with olive oil, sauteed crushed garlic and a dusting of soft cheese.

— * —

)clear all
--S 80 of 676
A(i) == 0.5*cos(i*%pi/100)
--R                                                                   Type: Void
--E 80
--S 81 of 676
B(i,j) == j/60.*sin(i*%pi/100)
--R                                                                   Type: Void
--E 81
--S 82 of 676
X(i,j) == 3*(1-sin(A(i)*2*%pi))*cos(A(i)*%pi+0.9*%pi)
--R                                                                   Type: Void
--E 82
--S 83 of 676
Y(i,j) == 3*sin(A(i)*2*%pi)*sin(A(i)*%pi+0.63*%pi)
--R                                                                   Type: Void
--E 83
--S 84 of 676
Z(i,j) == 4*B(i,j)*(5-sin(A(i)*%pi))
--R                                                                   Type: Void
--E 84

--S 85 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..200,j=0..30,_
          style=="smooth",title=="Cavatelli")
--R   Compiling function A with type Variable i -> Expression Float
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function B with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Expression
--R      Float
--I   Compiling function %XU with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %XW with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %XY with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (6)  ThreeDimensionalViewport: "Cavatelli"
--R                                               Type: ThreeDimensionalViewport
--E 85
--S 86 of 676
close(v3d)
--R                                                                   Type: Void
--E 86

———-

15 Chifferi Rigati

This pasta - available in both rigoti (grooved) and lisci (smooth) forms - is typically cooked in broth or served in rogu alla bolognese, though chifferi rigati also make an excellent addition to salads with carrot, red pepper and courgette. Chifferi rigoti bear a resemblance to, and the term is a transliteration of, the Austrian ’kipfel’ sweet.

— * —

)clear all
--S 87 of 676
X(i,j) == (0.45+0.3*cos(i*%pi/100)+0.005*cos(2*i*%pi/5)) * cos(j*%pi/45) + _
          0.15*(j/45.0)^10*cos(i*%pi/100)^3
--R                                                                   Type: Void
--E 87
--S 88 of 676

Y(i,j) == (0.35+j/300.0)*sin(i*%pi/100) + 0.005*sin(2*i*%pi/5)
--R                                                                   Type: Void
--E 88
--S 89 of 676
Z(i,j) == (0.4+0.3*cos(i*%pi/100))*sin(j*%pi/45)
--R                                                                   Type: Void
--E 89
--S 90 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..200,j=0..45,_
          style=="smooth",title=="Chifferi Rigati")
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Expression
--R      Float
--I   Compiling function %YG with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %YI with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %YK with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Chifferi Rigati"
--R                                               Type: ThreeDimensionalViewport
--E 90
--S 91 of 676
rotate(v3d,90,180)
--R                                                                   Type: Void
--E 91
--S 92 of 676
close(v3d)
--R                                                                   Type: Void
--E 92

———-

16 Colonne Pompeii

This ornate pasta (originally from Campania, southern Italy) is similar in shape to fusilloni (a large fusilli) but is substantially longer. Colonne Pompeii (columns of Pompeii) are best served with a seasoning of fresh basil, pine nuts, finely sliced garlic and olive oil, topped with a sprinkling of freshly grated Parmigiano-Reggiano.

— * —

--S 93 of 676
X0(i,j) == _
  if (j <= 50) _
   then 2*cos(i*%pi/20) _
   else 2*cos(i*%pi/20)*cos(-j*%pi/25)
--R                                                                   Type: Void
--E 93
--S 94 of 676
Y0(i,j) == _
  if (j <= 50) _
   then 0.0 _
   else 2*cos(i*%pi/20)*sin(-j*%pi/25) + 3*sin((j-50)*%pi/200)
--R                                                                   Type: Void
--E 94
--S 95 of 676
Z0(i,j) == _
  if (j <= 50) _
   then sin(i*%pi/20)+12 _
   else sin(i*%pi/20)+6.0*j/25.0
--R                                                                   Type: Void
--E 95
--S 96 of 676
X1(i,j) == _
  if (j <= 200) _
   then 2*cos(i*%pi/20)*cos(-j*%pi/25+2*%pi/3) _
   else 2*cos(i*%pi/20)*sin(-28*%pi/3)
--R                                                                   Type: Void
--E 96
--S 97 of 676
Y1(i,j) == _
  if (j <= 200) _
   then 2*cos(i*%pi/20)*sin(-j*%pi/20 + 2*%pi/3) + 3*sin(j*%pi/200) _
   else 2*cos(i*%pi/20)*sin(-28*%pi/3)
--R                                                                   Type: Void
--E 97
--S 98 of 676
Z1(i,j) == _
  if (j <= 200) _
   then 12+sin(i*%pi/20)+6.0*j/25.0 _
   else sin(i*%pi/20)+60
--R                                                                   Type: Void
--E 98

--S 99 of 676
X2(i,j) == _
  if (j <= 200) _
   then 2*cos(i*%pi/20)*cos(-j*%pi/25+4*%pi/3) _
   else 2*cos(i*%pi/20)*sin(-28*%pi/3)
--R                                                                   Type: Void
--E 99
--S 100 of 676
Y2(i,j) == _
  if (j <= 200) _
   then 2*cos(i*%pi/200)*sin(-j*%pi/25+4*%pi/3)+3*sin(j*%pi/200) _
   else 2*cos(i*%pi/20)*sin(-28*%pi/3)
--R                                                                   Type: Void
--E 100
--S 101 of 676
vsp:=createThreeSpace()
--R
--R   (9)  3-Space with 0 components
--R                                                 Type: ThreeSpace DoubleFloat
--E 101
--S 102 of 676
makeObject(surface(X0(i,j),Y0(i,j),Z0(i,j)),i=0..10,j=0..250,space==vsp)
--R   Compiling function X0 with type (Variable i,Variable j) ->
--R      Expression Integer
--R   Compiling function Y0 with type (Variable i,Variable j) ->
--R      Expression Float
--R   Compiling function Z0 with type (Variable i,Variable j) ->
--R      Expression Float
--I   Compiling function %ZK with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %ZM with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %ZO with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R
--R   (10)  3-Space with 1 component
--R                                                 Type: ThreeSpace DoubleFloat
--E 102
--S 103 of 676
makeObject(surface(X1(i,j),Y1(i,j),Z1(i,j)),i=0..10,j=0..250,space==vsp)
--R   Compiling function X1 with type (Variable i,Variable j) ->
--R      Expression Integer
--R   Compiling function Y1 with type (Variable i,Variable j) ->
--R      Expression Integer
--R   Compiling function Z1 with type (Variable i,Variable j) ->
--R      Expression Float

--I   Compiling function %ZQ with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %ZS with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %ZU with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R
--R   (11)  3-Space with 2 components
--R                                                 Type: ThreeSpace DoubleFloat
--E 103
--S 104 of 676
makeObject(surface(X2(i,j),Y2(i,j),Z1(i,j)),i=0..10,j=0..250,space==vsp)
--R   Compiling function X2 with type (Variable i,Variable j) ->
--R      Expression Integer
--R   Compiling function Y2 with type (Variable i,Variable j) ->
--R      Expression Integer
--I   Compiling function %ZW with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %ZY with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %BAA with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R
--R   (12)  3-Space with 3 components
--R                                                 Type: ThreeSpace DoubleFloat
--E 104
--S 105 of 676
vp:=makeViewport3D(vsp,"Colonne Pompeii")
--R   Transmitting data...
--R
--R   (13)  ThreeDimensionalViewport: "Colonne Pompeii"
--R                                               Type: ThreeDimensionalViewport
--E 105
--S 106 of 676
zoom(vp,3.0,3.0,3.0)
--R                                                                   Type: Void
--E 106
--S 107 of 676
close(vp)
--R                                                                   Type: Void
--E 107

———-

17 Conchiglie Rigate

Shaped like their namesake, conchiglie (shells) exist in both rigate (grooved) and lisce (smooth) forms. Suited to light tomato sauces, ricotta cheese or pesto genovese, conchiglie hold flavourings in their grooves and cunningly designed shell. Smaller versions are used in soups, while larger shells are more commonly served with a sauce.

— * —

)clear all
--S 108 of 676
A(i,j) == 0.25*sin(j*%pi/250)*cos((6*j+25)/25*%pi)
--R                                                                   Type: Void
--E 108
--S 109 of 676
B(i,j) == ((40.0-i)/40.0)*(0.3+sin(j*%pi/250))*%pi
--R                                                                   Type: Void
--E 109
--S 110 of 676
C(i,j) == 2.5*cos(j*%pi/125)+2*sin((40-i)*%pi/80)^10 * _
          sin(j*%pi/250)^10*sin(j*%pi/125+1.5*%pi)
--R                                                                   Type: Void
--E 110
--S 111 of 676
X(i,j) == A(i,j)+cos(j*%pi/125)+(5+30*sin(j*%pi/250))*sin(B(i,j)) * _
          sin(i/40*(0.1*(1.1+sin(j*%pi/250)^5))*%pi)
--R                                                                   Type: Void
--E 111
--S 112 of 676
Y(i,j) == A(i,j)+(5+30*sin(j*%pi/250))*cos(B(i,j)) * _
          sin(i/40*(0.1*(1.1+sin(j*%pi/250)^5))*%pi) + C(i,j)
--R                                                                   Type: Void
--E 112
--S 113 of 676
Z(i,j) == 25.0*cos(j*%pi/250)
--R                                                                   Type: Void
--E 113
--S 114 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..40,j=0..250,_
          style=="smooth",title=="Conchiglie Rigate")
--R   Compiling function A with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function B with type (Variable i,Variable j) -> Expression
--R      Float

--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function C with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Expression
--R      Float
--I   Compiling function %BAC with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %BAE with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %BAG with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (7)  ThreeDimensionalViewport: "Conchiglie Rigate"
--R                                               Type: ThreeDimensionalViewport
--E 114
--S 115 of 676
rotate(v3d,45,45)
--R                                                                   Type: Void
--E 115
--S 116 of 676
close(v3d)
--R                                                                   Type: Void
--E 116

———-

18 Conchigliette Lisce

Typically found in central and southern Italy (notably Campania), conchigliette lisce (small smooth shells) can be served in soups such as minestrone. Alternatively, these shells can accompany a meat- or vegetable-based sauce.

— * —

)clear all
--S 117 of 676
A(i,j) == (60.0-i)/60.0*(0.5+sin(j*%pi/60))*%pi
--R                                                                   Type: Void
--E 117
--S 118 of 676
B(i,j) == i/60.0*(0.1*(1.1+sin(j*%pi/60)^5))*%pi

--S 119 of 676
C(i,j) == 2.5*cos(j*%pi/30)+2*sin((60-i)*%pi/120)^10 * _
          sin(j*%pi/60)^10*sin((j+45)*%pi/30)
--R                                                                   Type: Void
--E 119
--S 120 of 676
X(i,j) == (5+30*sin(j*%pi/60))*sin(A(i,j))*sin(B(i,j))+cos(j*%pi/30)
--R                                                                   Type: Void
--E 120
--S 121 of 676
Y(i,j) == (5+30*sin(j*%pi/60))*cos(A(i,j))*sin(B(i,j))+C(i,j)
--R                                                                   Type: Void
--E 121
--S 122 of 676
Z(i,j) == 25*cos(j*%pi/60)
--R                                                                   Type: Void
--E 122
--S 123 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..60,j=0..60,_
          style=="smooth",title=="Conchigliette Lisce")
--R   Compiling function A with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function B with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function C with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Expression
--R      Integer
--I   Compiling function %F with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %H with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %J with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (7)  ThreeDimensionalViewport: "Conchigliette Lisce"
--R                                               Type: ThreeDimensionalViewport
--E 123

--S 124 of 676
rotate(v3d,45,45)
--R                                                                   Type: Void
--E 124
--S 125 of 676
close(v3d)
--R                                                                   Type: Void
--E 125

———-

19 Conchiglioni Rigate

The shape of conchiglioni rigate (large ribbed shells) is ideal for holding sauces and fillings (either fish or meat based) and the pasta can be baked in the oven, or placed under a grill and cooked as a gratin. Conchiglioni rigati are often served in the Italian-American dish pasta primavera (pasta in spring sauce) alongside crisp spring vegetables.

— * —

)clear all
--S 126 of 676
A(i,j) == 0.25*sin(j*%pi/200)*cos((j+4)*%pi/4)
--R                                                                   Type: Void
--E 126
--S 127 of 676
B(i,j) == i/40.0*(0.1+0.1*sin(j*%pi/200)^6)*%pi
--R                                                                   Type: Void
--E 127
--S 128 of 676
C(i,j) == 2.5*cos(j*%pi/100)+3*sin((40-i)*%pi/80)^10 * _
          sin(j*%pi/200)^10*sin((j-150)*%pi/100)
--R                                                                   Type: Void
--E 128
--S 129 of 676
X(i,j) == A(i,j)+(10+30*sin(j*%pi/200)) * _
          sin((40.0-i)/40*(0.3+sin(j*%pi/200)^3)*%pi) * _
          sin(B(i,j))+cos(j*%pi/100)
--R                                                                   Type: Void
--E 129
--S 130 of 676
Y(i,j) == A(i,j)+(10+30*sin(j*%pi/200)) * _

          cos((40.0-i)/40*(0.3+sin(j*%pi/200)^3)*%pi) * _
          sin(B(i,j))+C(i,j)
--R                                                                   Type: Void
--E 130
--S 131 of 676
Z(i,j) == 30.0*cos(j*%pi/200)
--R                                                                   Type: Void
--E 131
--S 132 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..40,j=0..200,_
          style=="smooth",title=="Conchiglioni Rigati")
--R   Compiling function A with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function B with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function C with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Expression
--R      Float
--I   Compiling function %YG with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %YI with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %YK with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (7)  ThreeDimensionalViewport: "Conchiglioni Rigati"
--R                                               Type: ThreeDimensionalViewport
--E 132
--S 133 of 676
rotate(v3d,45,45)
--R                                                                   Type: Void
--E 133
--S 134 of 676
close(v3d)
--R                                                                   Type: Void
--E 134

———-

20 Corallini Lisci

Members of the postine minute (tiny pasta) group, corallini lisci (small smooth coral) are so called because their pierced appearance resembles the coral beads worn as jewelry in Italy. Their small size (no larger than 3.5 mm in diameter) means that corallini are best cooked in broths, such as Tuscan white bean soup.

— * —

)clear all
--S 135 of 676
X(i,j) == 0.8*cos(i*%pi/50)
--R                                                                   Type: Void
--E 135
--S 136 of 676
Y(i,j) == 0.8*sin(i*%pi/50)
--R                                                                   Type: Void
--E 136
--S 137 of 676
Z(i,j) == 3.0*j/50.0
--R                                                                   Type: Void
--E 137
--S 138 of 676
vsp:=createThreeSpace()
--R
--R   (4)  3-Space with 0 components
--R                                                 Type: ThreeSpace DoubleFloat
--E 138
--S 139 of 676
makeObject(surface(X(i,j),Y(i,j),Z(i,j)),i=0..140,j=0..70,space==vsp)
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Polynomial
--R      Float
--I   Compiling function %F with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %H with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %J with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R
--R   (5)  3-Space with 1 component
--R                                                 Type: ThreeSpace DoubleFloat
--E 139

--S 140 of 676
makeObject(surface(X(i,j)/2,Y(i,j)/2,Z(i,j)),i=0..140,j=0..70,space==vsp)
--I   Compiling function %L with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %N with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %P with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R
--R   (6)  3-Space with 2 components
--R                                                 Type: ThreeSpace DoubleFloat
--E 140
--S 141 of 676
vp:=makeViewport3D(vsp,style=="smooth",title=="Corallini Lisci")
--R   Transmitting data...
--R
--R   (7)  ThreeDimensionalViewport: "Corallini Lisci"
--R                                               Type: ThreeDimensionalViewport
--E 141
--S 142 of 676
zoom(vp,2.0,2.0,2.0)
--R                                                                   Type: Void
--E 142
--S 143 of 676
close(vp)
--R                                                                   Type: Void
--E 143

———-

21 Creste Di Galli

Part of the pasta ripiena (filled pasta) family, creste di galli (coxcombs) are identical to galletti except for the crest, which is smooth rather than crimped. They may be stuffed, cooked and served in a simple marinara (mariner’s) sauce, which contains tomato, garlic, and basil.

— * —

)clear all
--S 144 of 676
A(i)   == ((1+sin((1.5+i)*%pi))/2)^5
--R                                                                   Type: Void
--E 144

--S 145 of 676
B(i,j) == 0.3*sin(A(i/140.)*%pi+0.5*%pi)^1000*cos(j*%pi/70.0)
--R                                                                   Type: Void
--E 145
--S 146 of 676
C(i,j) == 0.3*cos(A(i/140.)*%pi)^1000*sin(j*%pi/70.0)
--R                                                                   Type: Void
--E 146
--S 147 of 676
X(i,j) == (0.5+0.3*cos(A(i/140.)*2*%pi))*cos(j*%pi/70.0) + _
          0.15*(j/70.0)^10*cos(A(i/140.0)*2*%pi)^3 + B(i,j)
--R                                                                   Type: Void
--E 147
--S 148 of 676
Y(i,j) == 0.35*sin(A(i/140.0)*2*%pi) + 0.15*j/70.0*sin(A(i/140.0)*2*%pi)
--R                                                                   Type: Void
--E 148
--S 149 of 676
Z(i,j) == (0.4+0.3*cos(A(i/140.0)*2*%pi))*sin(j*%pi/70.0) + C(i,j)
--R                                                                   Type: Void
--E 149
--S 150 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..140,j=0..70,_
          style=="smooth",title=="Creste Di Galli")
--R   Compiling function A with type Polynomial Float -> Expression Float
--R   Compiling function B with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function C with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Expression
--R      Float
--I   Compiling function %R with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %T with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %V with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (7)  ThreeDimensionalViewport: "Creste Di Galli"

--R                                               Type: ThreeDimensionalViewport
--E 150
--S 151 of 676
close(v3d)
--R                                                                   Type: Void
--E 151

———-

22 Couretti

A romantically shaped scion of the postine minute (tiny pasta) clan, cuoretti (tiny hearts) are minuscule. In fact, along with acini di pepe, they are one of the smallest forms of pasta. Like all postine they may be served in soup, such as cream of chicken.

— * —

)clear all
--S 152 of 676
X(i,j) == 2*cos(i*%pi/150)-cos(i*%pi/75)-sin(i*%pi/300)^150 - _
          (abs(cos(i*%pi/300)))^5
--R                                                                   Type: Void
--E 152
--S 153 of 676
Y(i,j) == 2*sin(i*%pi/150)-sin(i*%pi/75)
--R                                                                   Type: Void
--E 153
--S 154 of 676
Z(i,j) == j/10.0
--R                                                                   Type: Void
--E 154
--S 155 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..300,j=0..10,_
          style=="smooth",title=="Couretti")
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Integer
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Integer
--R   Compiling function Z with type (Variable i,Variable j) -> Polynomial
--R      Float
--I   Compiling function %Z with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %BB with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat

--I   Compiling function %BD with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Couretti"
--R                                               Type: ThreeDimensionalViewport
--E 155
--S 156 of 676
close(v3d)
--R                                                                   Type: Void
--E 156

———-

23 Ditali Rigati

Another speciality of the Campania region of southern Italy, ditali rigati (grooved thimbles) are compact and typically less than 10 mm long. Like other pastine, they are usually found in soups such as pasta e patate. Their stocky shape makes them a sustaining winter snack, as well as an excellent addition to salads.

— * —

)clear all
--S 157 of 676
X(i,j) ==       cos(i*%pi/100) + 0.03*cos((7*i)*%pi/40) + 0.25*cos(j*%pi/50)
--R                                                                   Type: Void
--E 157
--S 158 of 676
Y(i,j) == 1.1 * sin(i*%pi/100) + 0.03*sin((7*i)*%pi/40) + 0.25*sin(j*%pi/50)
--R                                                                   Type: Void
--E 158
--S 159 of 676
Z(i,j) == j/10.0
--R                                                                   Type: Void
--E 159
--S 160 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..200,j=0..25,_
          style=="smooth",title=="Ditali Rigati")
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Polynomial

--R      Float
--I   Compiling function %BF with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %BH with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %BJ with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Ditali Rigati"
--R                                               Type: ThreeDimensionalViewport
--E 160
--S 161 of 676
close(v3d)
--R                                                                   Type: Void
--E 161

———-

24 Fagottini

A notable member of the pasta ripiena (filled pasta) family, fagottini (little purses) are made from circles of durum wheat dough. A spoonful of ricotta, steamed vegetables or even stewed fruit is placed on the dough, and the corners are then pinched together to form a bundle. These packed dumplings are similar to ravioli, only larger.

— * —

)clear all
--S 162 of 676
A(i,j) == (0.8 + sin(i/100*%pi)^8 - 0.8 * cos(i/25*%pi))^1.5 + _
           0.2 + 0.2 * sin(1/100*%pi)
--R
--R                                                                   Type: Void
--E 162
--S 163 of 676
B(i,j) == (0.9 + cos(i/100*%pi)^8 - 0.9 * cos(i/25*%pi + 0.03*%pi))^1.5 + _
           0.3 * cos(i/100*%pi)
--R
--R                                                                   Type: Void
--E 163
--S 164 of 676
C(i,j) == 4 - ((4*j)/500)*(1+cos(i/100*%pi)^8 - 0.8*cos(i/25*%pi))^1.5
--R
--R                                                                   Type: Void

--E 164
--S 165 of 676
X(i,j) == cos(i/100*%pi) * _
          (A(i,j) * sin(j/100*%pi)^8 + _
           0.6 * (2 + sin(i/100*%pi)^2) * sin(j/50*%pi)^2)
--R
--R                                                                   Type: Void
--E 165
--S 166 of 676
Y(i,j) == sin(i/100*%pi) * _
          (B(i,j) * sin(j/100*%pi)^8 + _
           0.6 * (2 + cos(i/100*%pi)^2) * sin(j/50*%pi)^2)
--R
--R                                                                   Type: Void
--E 166
--S 167 of 676
Z(i,j) == (1 + sin(j/100*%pi - 0.5*%pi)) * _
           (C(i,j) * ((4*j)/500) * _
            (1 + sin(i/100*%pi)^8 - 0.8 * cos(i/25*%pi))^1.5)
--R
--R                                                                   Type: Void
--E 167
--S 168 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..200,j=0..50,_
          style=="smooth",title=="Fagottini")
--R
--R   Compiling function A with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function B with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function C with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Expression
--R      Float
--I   Compiling function %EV with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %EX with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %EZ with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R

--R   (7)  ThreeDimensionalViewport: "Fagottini"
--R                                               Type: ThreeDimensionalViewport
--E 168
--S 169 of 676
close(v3d)
--R                                                                   Type: Void
--E 169

———-

25 Farfalle

A mixture of durum-wheat flour, eggs, and water, farfalle (butterflies) come from the Emilia-Romagnaand Lombardy regions of northern Italy. They are best served in a rich carbonara sauce (made with cream, eggs, and bacon). Depending on se, farfalle might be accompanied by green peas and chicken or ham.

— * —

)clear all
--S 170 of 676
A(i)   == sin((7*i+16)*%pi/40)
--R                                                                   Type: Void
--E 170
--S 171 of 676
B(i,j) == (7.0*j/16.0)+4*sin(i*%pi/80)*sin((j-10)*%pi/120)
--R                                                                   Type: Void
--E 171
--S 172 of 676
C(i,j) == 10*cos((i+80)*%pi/80)*sin((j+110)*%pi/100)^9
--R                                                                   Type: Void
--E 172
--S 173 of 676
D(i,j) == (7.0*j/16.0)-4*sin(i*%pi/80)-A(i)*sin((10-j)*%pi/20)
--R                                                                   Type: Void
--E 173
--S 174 of 676
E(i,j) == 0.0 -- This was never defined.
--R                                                                   Type: Void
--E 174
--S 175 of 676
X(i,j) == _

  if ((20 <= i) and (i <= 60)) _
   then 7*sin((i+40)*%pi/40)^3*sin((j+110)*%pi/100)^9+(3.0*i)/8.0 _
   else C(i,j)+(3.0*i)/8.0
--R                                                                   Type: Void
--E 175
--S 176 of 676
Y(i,j) == _
  if ((10 <= j) and (j <= 70)) _
   then B(i,j)-4*sin(i*%pi/80)*sin((70-j)*%pi/120) _
   else if (j <= 10) _
         then D(i,j) _
         else E(i,j)
--R                                                                   Type: Void
--E 176
--S 177 of 676
Z(i,j) == 3*sin((i+10)*%pi/20)*sin(j*%pi/80)^1.5
--R                                                                   Type: Void
--E 177
--S 178 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..80,j=0..80,_
          style=="smooth",title=="Farfalle")
--R   Compiling function C with type (Variable i,Variable j) -> Expression
--R      Integer
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function B with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function A with type Variable i -> Expression Integer
--R   Compiling function D with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function E with type (Variable i,Variable j) -> Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Expression
--R      Float
--I   Compiling function %BL with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %BN with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %BP with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (9)  ThreeDimensionalViewport: "Farfalle"
--R                                               Type: ThreeDimensionalViewport
--E 178

--S 179 of 676
zoom(v3d,0.5,0.5,0.5)
--R                                                                   Type: Void
--E 179
--S 180 of 676
close(v3d)
--R                                                                   Type: Void
--E 180

———-

26 Farfalline

The small size of this well-known member of the postine minute (tiny pasta) lineage means that farfalline (tiny butterflies), are suitable for light soups, such as pomodori e robiolo (a mixture of tomato and soft cheese). A crimped pasta cutter and a central pinch create the iconic shape.

— * —

)clear all
--S 181 of 676
A(i) == 30*cos(i*%pi/125)+0.5*cos((6*i)*%pi/25)
--R                                                                   Type: Void
--E 181
--S 182 of 676
B(i) == 30*sin(i*%pi/125)+0.5*sin((6*i)*%pi/25)
--R                                                                   Type: Void
--E 182
--S 183 of 676
X(i,j) == cos(3*A(i)*%pi/100)
--R                                                                   Type: Void
--E 183
--S 184 of 676
Y(i,j) == 0.5*sin((3*A(i))*%pi/100)*(1+sin(j*%pi/100)^10)
--R                                                                   Type: Void
--E 184
--S 185 of 676
Z(i,j) == B(i)*j/500.0
--R                                                                   Type: Void
--E 185
--S 186 of 676

v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..250,j=0..50,_
          style=="smooth",title=="Farfalline")
--R   Compiling function A with type Variable i -> Expression Float
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function B with type Variable i -> Expression Float
--R   Compiling function Z with type (Variable i,Variable j) -> Expression
--R      Float
--I   Compiling function %BR with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %BT with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %BV with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (6)  ThreeDimensionalViewport: "Farfalline"
--R                                               Type: ThreeDimensionalViewport
--E 186
--S 187 of 676
rotate(v3d,45,45)
--R                                                                   Type: Void
--E 187
--S 188 of 676
close(v3d)
--R                                                                   Type: Void
--E 188

———-

27 Farfalloni

Like farfalle, farfalloni (large butterflies) are well matched by a tomato- or butter-based sauce with peas and ham. They are also perfect with marrow vegetables such as roast courgette or pureed pumpkin, topped with Parmigiano-Reggiano and a sprinkling of noce moscata (nutmeg).

— * —

)clear all
--S 189 of 676
A(i,j) == 10*cos((i+70)*%pi/70)*sin((2*j)*%pi/175+1.1*%pi)^9
--R                                                                   Type: Void
--E 189

--S 190 of 676
B(j)   == 0.3*sin((6-j)*%pi/7+0.4*%pi)
--R                                                                   Type: Void
--E 190
--S 191 of 676
C(i,j) == _
  if ((17 <= i) and (i <= 52)) _
   then 7*sin((i+35)*%pi/35)^3*sin((2*j*%pi)/175+1.1*%pi)^9 _
   else A(i,j)
--R                                                                   Type: Void
--E 191
--S 192 of 676
D(i,j) == (j/2.0)+4*sin(i*%pi/70)*sin((j-10)*%pi/100) - _
          4*sin(i*%pi/70)*sin((60-j)*%pi/100)
--R                                                                   Type: Void
--E 192
--S 193 of 676
E(i,j) == (j/2.0)+4*sin(i*%pi/70)+0.3*sin((2*i+2.8)*%pi/7)*sin((j-60)*%pi/20)
--R                                                                   Type: Void
--E 193
--S 194 of 676
F(i,j) == (j/2.0)-4*sin(i*%pi/70)-0.3*sin((2*i+2.8)*%pi/7)*sin((10-j)*%pi/20)
--R                                                                   Type: Void
--E 194
--S 195 of 676
X(i,j) == (3.0*i)/7.0+C(i,j)
--R                                                                   Type: Void
--E 195
--S 196 of 676
Y(i,j) == _
  if ((10 <= j) and (j <= 60)) _
   then D(i,j) _
   else if (j <= 10) _
         then F(i,j) _
         else E(i,j)
--R                                                                   Type: Void
--E 196
--S 197 of 676
Z(i,j) == 3*sin((2*i+17.5)*%pi/35.)*sin(j*%pi/70)^1.5
--R                                                                   Type: Void
--E 197

--S 198 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..70,j=0..70,_
          style=="smooth",title=="Farfalloni")
--R   Compiling function A with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function C with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function D with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function F with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function E with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Expression
--R      Float
--I   Compiling function %BX with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %BZ with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %CB with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (10)  ThreeDimensionalViewport: "Farfalloni"
--R                                               Type: ThreeDimensionalViewport
--E 198
--S 199 of 676
zoom(v3d,2.5,2.5,2.5)
--R                                                                   Type: Void
--E 199
--S 200 of 676
close(v3d)
--R                                                                   Type: Void
--E 200

———-

28 Festonati

This smooth member of the pasta corta (short pasta) family is named after ’festoons’ (decorative lengths of fabric with the rippled profile of a garland). Festonati can be served with grilled aubergine or home-grown tomatoes, topped with grated scamorza, fresh basil, olive oil, garlic, and red chilli flakes.

— * —

)clear all
--S 201 of 676
X(i,j) == 5*cos(i*%pi/50)+0.5*cos(i*%pi/50)*(1+sin(j*%pi/100)) + _
          0.5*cos((i+25)*%pi/25)*(1+sin(j*%pi/5))
--R                                                                   Type: Void
--E 201
--S 202 of 676
Y(i,j) == 5*sin(i*%pi/50)+0.5*sin(i*%pi/50)*(1+sin(j*%pi/100)) + _
          0.5*cos(i**%pi/25)*(1+sin(j*%pi/5))
--R                                                                   Type: Void
--E 202
--S 203 of 676
Z(i,j) == j/2.0+2*sin((3*i+25)*%pi/50)
--R                                                                   Type: Void
--E 203
--S 204 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..100,j=0..100,_
          style=="smooth",title=="Festonati")
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Expression
--R      Float
--I   Compiling function %CD with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %CF with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %CH with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Festonati"
--R                                               Type: ThreeDimensionalViewport
--E 204
--S 205 of 676
zoom(v3d,3.0,3.0,3.0)
--R                                                                   Type: Void
--E 205
--S 206 of 676
close(v3d)

———-

29 Fettuccine

This famous pasta lunga (long pasta) is made with durum-wheat flour, water, and in the case of fettuccine alluovo, eggs ideally within days of laying. Fettuccine (little ribbons) hail from the Lazio region. Popular in many dishes, they are an ideal accompaniment to Alfredo sauce, a rich mix of cream, parmesan, garlic, and parsley.

— * —

)clear all
--S 207 of 676
X(i,j) == 1.8*sin((4-i)*%pi/375)
--R                                                                   Type: Void
--E 207
--S 208 of 676
Y(i,y) == 1.6*cos((6-i)*%pi/375)*sin((3-i)*%pi/750)
--R                                                                   Type: Void
--E 208
--S 209 of 676
Z(i,j) == i/75.0 + j/20.0
--R                                                                   Type: Void
--E 209
--S 210 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..150,j=0..10,_
          style=="smooth",title=="Fettuccine")
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Polynomial
--R      Float
--I   Compiling function %CJ with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %CL with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %CN with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Fettuccine"

--S 211 of 676
zoom(v3d,2.0,2.0,2.0)
--R                                                                   Type: Void
--E 211
--S 212 of 676
close(v3d)
--R                                                                   Type: Void
--E 212

———-

30 Fiocchi Rigati

A distant relative of the farfalle family, fiocchi rigati (grooved flakes) are smaller than either farfalloni or farfalle, but larger than farfalline. Their corrugated surface collects more sauce than a typical farfalle. For a more unusual disk, fiocchi rigati can be served in a tomato and vodka sauce.

— * —

)clear all
--S 213 of 676
A(i,j) == 10*cos((i+80)*%pi/80)*sin((j+110)*%pi/100)^9
--R                                                                   Type: Void
--E 213
--S 214 of 676
B(i,j) == 35.0*j/80.0+4*sin(i*%pi/80)*sin((j-10)*%pi/120)
--R                                                                   Type: Void
--E 214
--S 215 of 676
X(i,j) == _
  if ((20 <= i) and (i <= 60)) _
   then 7*sin((i+40)*%pi/40)^3*sin((j+110)*%pi/100)^9 + 30.0*i/80.0 _
   else A(i,j) + 30.0*i/80.0
--R                                                                   Type: Void
--E 215
--S 216 of 676
Y(i,j) == B(i,j)-4*sin(i*%pi/80)*sin((70-j)*%pi/120)
--R                                                                   Type: Void
--E 216

--S 217 of 676
Z(i,j) == 3*sin((1+10)*%pi/20)*sin(j*%pi/80)^1.5-0.7*((sin(3*j*%pi/8)+1)/2)^4
--R                                                                   Type: Void
--E 217
--S 218 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..80,j=0..80,_
           style=="smooth",title=="Fiocchi Rigati")
--R   Compiling function A with type (Variable i,Variable j) -> Expression
--R      Integer
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function B with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Expression
--R      Float
--I   Compiling function %CP with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %CR with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %CT with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (6)  ThreeDimensionalViewport: "Fiocchi Rigati"
--R                                               Type: ThreeDimensionalViewport
--E 218
--S 219 of 676
zoom(v3d,2.0,2.0,2.0)
--R                                                                   Type: Void
--E 219
--S 220 of 676
close(v3d)
--R                                                                   Type: Void
--E 220

———-

31 Fisarmoniche

Named after the accordion - whose bellows their bunched profiles recall - fisarmoniche are perfect for capturing thick sauces, which cling to their folds. This sturdy pasta is said to have been invented in the fifteenth century, in the Italian town of Loreto in the Marche, east central Italy.

— * —

)clear all
--S 221 of 676
X(i,j) == (1.5+3*(i/70.0)^5+4*sin(j*%pi/200)^50)*cos(4*i*%pi/175)
--R                                                                   Type: Void
--E 221
--S 222 of 676
Y(i,j) == (1.5+3*(i/70.0)^5+4*sin(j*%pi/200)^50)*sin(4*i*%pi/175)
--R                                                                   Type: Void
--E 222
--S 223 of 676
Z(i,j) == j/50.0+cos(3*i*%pi/14)*sin(j*%pi/1000)
--R                                                                   Type: Void
--E 223
--S 224 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..70,j=0..1000,_
           style=="smooth",title=="Fisarmoniche")
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Expression
--R      Float
--I   Compiling function %CV with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %CX with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %CZ with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Fisarmoniche"
--R                                               Type: ThreeDimensionalViewport
--E 224
--S 225 of 676
zoom(v3d,2.0,2.0,2.0)
--R                                                                   Type: Void
--E 225
--S 226 of 676
close(v3d)
--R                                                                   Type: Void
--E 226

32 Funghini

The modest dimensions of this pastine minute (tiny pasta) make funghini (little mushrooms) especially suitable for soups, such as a minestrone made from chopped and sauteed celeriac.

— * —

)clear all
--S 227 of 676
A(i,j) == 5*cos(i*%pi/150)+0.05*cos(i*%pi/3)*sin(j*%pi/60)^2000
--R                                                                   Type: Void
--E 227
--S 228 of 676
B(i,j) == j/30.0*(5*sin(i*%pi/150)+0.05*sin(i*%pi/3))
--R                                                                   Type: Void
--E 228
--S 229 of 676
C(i,j) == j/10.0*(2*sin(i*%pi/150)+0.05*sin(i*%pi/3))
--R                                                                   Type: Void
--E 229
--S 230 of 676
D(i,j) == _
  if (i <= 150) _
   then B(i,j) _
   else if (j <= 10) _
         then C(i,j) _
         else 2*sin(i*%pi/150)+0.05*sin(i*%pi/6)
--R                                                                   Type: Void
--E 230
--S 231 of 676
X(i,j) == 0.05*cos(A(i,j)*%pi/5)+0.3*cos(A(i,j)*%pi/5)*sin(3*D(i,j)*%pi/50)^2
--R                                                                   Type: Void
--E 231
--S 232 of 676
Y(i,j) == 0.01*sin(A(i,j)*%pi/5)+0.3*sin(A(i,j)*%pi/5)*sin(3*D(i,j)*%pi/50)^2
--R                                                                   Type: Void
--E 232
--S 233 of 676
Z(i,j) == 0.25*sin((D(i,j)+3)*%pi/10)

--S 234 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..300,j=0..30,_
           style=="smooth",title=="Funghini")
--R   Compiling function A with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function B with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function C with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function D with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Expression
--R      Float
--I   Compiling function %DB with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %DD with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %DF with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (8)  ThreeDimensionalViewport: "Funghini"
--R                                               Type: ThreeDimensionalViewport
--E 234
--S 235 of 676
close(v3d)
--R                                                                   Type: Void
--E 235

———-

33 Fusilli

A popular set from the pasta corta (short pasta) family, fusilli (little spindles) were originally made by quickly wrapping a spaghetto around a large needle. Best served as pastasciutta (pasta boild and drained) with a creamy sauce containing slices of spicy sausage.

— * —

)clear all

--S 236 of 676
X(i,j) == 6*cos((3*i+10)*%pi/100)*cos(j*%pi/25)
--R                                                                   Type: Void
--E 236
--S 237 of 676
Y(i,j) == 6*sin((3*i+10)*%pi/100)*cos(j*%pi/25)
--R                                                                   Type: Void
--E 237
--S 238 of 676
Z(i,j) == (3.0*i)/20.0+2.5*cos((j+12.5)*%pi/25)
--R                                                                   Type: Void
--E 238
--S 239 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..200,j=0..25,_
           style=="smooth",title=="Fusilli")
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Integer
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Integer
--R   Compiling function Z with type (Variable i,Variable j) -> Expression
--R      Float
--I   Compiling function %DH with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %DJ with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %DL with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Fusilli"
--R                                               Type: ThreeDimensionalViewport
--E 239
--S 240 of 676
zoom(v3d,2.0,2.0,2.0)
--R                                                                   Type: Void
--E 240
--S 241 of 676
close(v3d)
--R                                                                   Type: Void
--E 241

———-

34 Fusilli al Ferretto

To create this Neapolitan variety of fusilli, a small amount of durum-wheat flour is kneaded and placed along a ferretto (small iron stick) that is then rolled between the hands to create a thick irregular twist of dough. The shape is removed and left to dry on a wicker tray known as a spasa. Fusilli al ferretto are best dished up with a lamb ragu.

— * —

)clear all
--S 242 of 676
A(i,j) == 6.0*i/7.0+15*cos(j*%pi/20)
--R                                                                   Type: Void
--E 242
--S 243 of 676
X(i,j) == (3+1.5*sin(i*%pi/140)^0.5*sin(j*%pi/20))*sin(13*i*%pi/280) + _
          5*sin(2*A(i,j)*%pi/135)
--R                                                                   Type: Void
--E 243
--S 244 of 676
Y(i,j) == (3+1.5*sin(i*%pi/140)^0.5*sin(j*%pi/20))*cos(13*i*%pi/280)
--R                                                                   Type: Void
--E 244
--S 245 of 676
Z(i,j) == A(i,j)
--R                                                                   Type: Void
--E 245
--S 246 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..140,j=0..40,_
           style=="smooth",title=="Fusilli al Ferretto")
--R   Compiling function A with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Expression
--R      Float
--I   Compiling function %DN with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %DP with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %DR with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R

--R   (5)  ThreeDimensionalViewport: "Fusilli al Ferretto"
--R                                               Type: ThreeDimensionalViewport
--E 246
--S 247 of 676
zoom(v3d,3.0,3.0,3.0)
--R                                                                   Type: Void
--E 247
--S 248 of 676
close(v3d)
--R                                                                   Type: Void
--E 248

———-

35 Fusilli Capri

A longer and more compact regional adaptation of fusilli, fusilli Capri are suited to a hearty ragu of lamb or por sausages, or may also be combined with rocket and lemon to form a lighter dish.

— * —

)clear all
--S 249 of 676
X(i,j) == 6*cos(j*%pi/50)*cos((i+2.5)*%pi/25)
--R                                                                   Type: Void
--E 249
--S 250 of 676
Y(i,j) == 6*cos(j*%pi/50)*sin((i+2.5)*%pi/25)
--R                                                                   Type: Void
--E 250
--S 251 of 676
Z(i,j) == 2.0*i/3.0 + 14*cos((j+25)*%pi/50)
--R                                                                   Type: Void
--E 251
--S 252 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..150,j=0..50,_
           style=="smooth",title=="Fusilli Capri")
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Expression

--R      Float
--I   Compiling function %DT with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %DV with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %DX with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Fusilli Capri"
--R                                               Type: ThreeDimensionalViewport
--E 252
--S 253 of 676
zoom(v3d,2.0,2.0,2.0)
--R                                                                   Type: Void
--E 253
--S 254 of 676
close(v3d)
--R                                                                   Type: Void
--E 254

———-

36 Fusilli Lunghi Bucati

A distinctive member of the extended fusilli clan, fusilli lunghi bucati (long pierced fusilli) originated in Campania, southern Italy, and have a spring-like profile. Like all fusilli they are traditionally consumed with a meat-based ragu, but may also be combined with thick vegetable sauces and baked in an oven.

— * —

)clear all
--S 255 of 676
A(i,j) == 10+cos(i*%pi/10)+2*cos((j+10)*%pi/10)+10*cos((j+140)*%pi/160)
--R                                                                   Type: Void
--E 255
--S 256 of 676
B(i,j) == 20+cos(i*%pi/10)+2*cos((j+10)*%pi/10)
--R                                                                   Type: Void
--E 256
--S 257 of 676
C(i,j) == (j+10.0)*%pi/10.0
--R                                                                   Type: Void

--E 257
--S 258 of 676
D(i,j) == i*%pi/10.0
--R                                                                   Type: Void
--E 258
--S 259 of 676
E(i,j) == 7+20*sin((j-20)*%pi/160)
--R                                                                   Type: Void
--E 259
--S 260 of 676
F(i,j) == 70*(0.1-(j-180.0)/200.0)
--R                                                                   Type: Void
--E 260
--S 261 of 676
X(i,j) == _
  if ((20 <= j) and (j <= 180)) _
   then A(i,j) _
   else if (j <= 20) _
         then cos(D(i,j))+2*cos(C(i,j)) _
         else B(i,j)
--R                                                                   Type: Void
--E 261
--S 262 of 676
Y(i,j) == _
  if ((20 <= j) and (j <= 180)) _
   then sin(D(i,j))+2*sin(C(i,j)) _
   else sin(D(i,j))+2*sin(C(i,j))
--R                                                                   Type: Void
--E 262
--S 263 of 676
Z(i,j) == _
  if ((20 <= j) and (j <= 180)) _
   then E(i,j) _
   else if (j <= 20) _
         then (7.0*j/20.0) _
         else F(i,j)
--R                                                                   Type: Void
--E 263
--S 264 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..20,j=0..200,_
           style=="smooth",title=="Fusilli Lunghi Bucati")
--R   Compiling function A with type (Variable i,Variable j) -> Expression
--R      Integer

--R   Compiling function D with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function C with type (Variable i,Variable j) -> Polynomial
--R      Float
--R   Compiling function B with type (Variable i,Variable j) -> Expression
--R      Integer
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function E with type (Variable i,Variable j) -> Expression
--R      Integer
--R   Compiling function F with type (Variable i,Variable j) -> Polynomial
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Expression
--R      Float
--I   Compiling function %DZ with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %EB with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %ED with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (10)  ThreeDimensionalViewport: "Fusilli Lunghi Bucati"
--R                                               Type: ThreeDimensionalViewport
--E 264
--S 265 of 676
zoom(v3d,2.0,2.0,2.0)
--R                                                                   Type: Void
--E 265
--S 266 of 676
close(v3d)
--R                                                                   Type: Void
--E 266

———-

37 Galletti

According to their maker, Barilla, the origin of galletti (small cocks) is uncertain, but their shape recalls that of the chifferi with the addtion of an undulating crest. Galletti are usually served in tomato sauces, but combine wqually well with a boscaiola (woodsman’s) sauce of mushrooms.

— * —

--S 267 of 676
A(i)   == (1+sin(i*%pi+1.5*%pi)/2)^5
--R                                                                   Type: Void
--E 267
--S 268 of 676
B(i,j) == 0.4*sin(A(i/140)*%pi+0.5*%pi)^1000*cos(j*%pi/70)
--R                                                                   Type: Void
--E 268
--S 269 of 676
C(i,j) == 0.15*sin(A(i/140)*%pi+0.5*%pi)^1000*cos(j*%pi/7)
--R                                                                   Type: Void
--E 269
--S 270 of 676
D(i,j) == 0.4*cos(A(i/140)*%pi)^1000*sin(j*%pi/70)
--R                                                                   Type: Void
--E 270
--S 271 of 676
X(i,j) == (0.5+0.3*cos(A(i/140)*2*%pi))*cos(j*%pi/70) + _
          0.15*(j/70.0)^10*cos(A(i/140)*2*%pi)^3 + B(i,j)
--R                                                                   Type: Void
--E 271
--S 272 of 676
Y(i,j) == 0.35*sin(A(i/140)*2*%pi)+0.15*(j/70.0)*sin(A(i/140)*2*%pi)+C(i,j)
--R                                                                   Type: Void
--E 272
--S 273 of 676
Z(i,j) == (0.4+0.3*cos(A(i/140)*2*%pi))*sin(j*%pi/70) + D(i,j)
--R                                                                   Type: Void
--E 273
--S 274 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..140,j=0..70,_
           style=="smooth",title=="Galletti")
--R   Compiling function A with type Polynomial Fraction Integer ->
--R      Expression Float
--R   Compiling function B with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function C with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression

--R      Float
--R   Compiling function D with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Expression
--R      Float
--I   Compiling function %EF with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %EH with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %EJ with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (8)  ThreeDimensionalViewport: "Galletti"
--R                                               Type: ThreeDimensionalViewport
--E 274
--S 275 of 676
close(v3d)
--R                                                                   Type: Void
--E 275

———-

38 Garganelli

A grooved pasta corta (short pasta), similar to maccheroni but with pointed slanting ends, garganelli are shaped like the gullet of a chicken (’garganel’ in the northern Italian Emiliano-Romagnolo dialect). Traditionally cooked in broth, garganelli are also sometimes served in hare sauce with chopped bacon.

— * —

)clear all
--S 276 of 676
A(i,j) == (i-25.0)/125.0*j
--R                                                                   Type: Void
--E 276
--S 277 of 676
B(i,j) == (i-25.0)/125.0*(150.0-j)
--R                                                                   Type: Void
--E 277
--S 278 of 676
C(i,j) == _
  if ((j <= 75) or (i <= 25)) _
   then A(i,j) _

   else if ((J >= 75) or (i <= 25)) _
         then B(i,j) _
         else if ((j >= 75) or (i >= 25)) _
               then B(i,j) _
               else A(i,j)
--R                                                                   Type: Void
--E 278
--S 279 of 676
X(i,j) == 0.1*cos(j*%pi/3)+(3+sin(C(i,j)*%pi/60))*cos(7*C(i,j)*%pi/60)
--R                                                                   Type: Void
--E 279
--S 280 of 676
Y(i,j) == 0.1*sin(j*%pi/3)+(3+sin(C(i,j)*%pi/60))*sin(7*C(i,j)*%pi/60)
--R                                                                   Type: Void
--E 280
--S 281 of 676
Z(i,j) == 6.0*j/25.0+C(i,j)/4.0
--R                                                                   Type: Void
--E 281
--S 282 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..50,j=0..150,_
           style=="smooth",title=="Garganelli")
--R   Compiling function A with type (Variable i,Variable j) -> Polynomial
--R      Float
--R   Compiling function B with type (Variable i,Variable j) -> Polynomial
--R      Float
--R   Compiling function C with type (Variable i,Variable j) -> Polynomial
--R      Float
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Polynomial
--R      Float
--I   Compiling function %EL with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %EN with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %EP with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (7)  ThreeDimensionalViewport: "Garganelli"
--R                                               Type: ThreeDimensionalViewport
--E 282

--S 283 of 676
zoom(v3d,2.0,2.0,2.0)
--R                                                                   Type: Void
--E 283
--S 284 of 676
close(v3d)
--R                                                                   Type: Void
--E 284

———-

39 Gemelli

To create a gemello, a single pasta strand is twisted into a spiral with a deceptively dual appearance. In the south of Italy gemelli (twins) are served with tomato, mozzarella, and basil, while in the northwest they are preferred with pesto and green beans, or in salads.

— * —

)clear all
--S 285 of 676
X(i,j) == 6*cos(j*1.9*%pi/50+0.55*%pi)*cos(3.0*i/25.0)
--R                                                                   Type: Void
--E 285
--S 286 of 676
Y(i,j) == 6*cos(j*1.9*%pi/50+0.55*%pi)*sin(3.0*i/25.0)
--R                                                                   Type: Void
--E 286
--S 287 of 676
Z(i,j) == 8*sin(j*1.9*%pi/50+0.55*%pi)+3.0*i/4.0
--R                                                                   Type: Void
--E 287
--S 288 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..100,j=0..50,_
           style=="smooth",title=="Gemelli")
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Expression
--R      Float
--I   Compiling function %ER with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %ET with type (DoubleFloat,DoubleFloat) ->

--R      DoubleFloat
--I   Compiling function %EV with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Gemelli"
--R                                               Type: ThreeDimensionalViewport
--E 288
--S 289 of 676
zoom(v3d,2.0,2.0,2.0)
--R                                                                   Type: Void
--E 289
--S 290 of 676
close(v3d)
--R                                                                   Type: Void
--E 290

———-

40 Gigli

With their fluted edges and cone-like shape, gigli resemble small bells (campanelle) or lilies (gigli), after which they are named. Another more recent design, gigli are shaped to capture thick meaty sauces.

— * —

)clear all
--S 291 of 676
X(i,j) == (0.8-0.6*sin(j*%pi/80)^0.5)*cos(i*%pi/50)+0.08*sin(j*%pi/40)
--R                                                                   Type: Void
--E 291
--S 292 of 676
Y(i,j) == (0.8-0.6*sin(j*%pi/80)^0.5)*sin(i*%pi/50)+0.08*sin(j*%pi/40)
--R                                                                   Type: Void
--E 292
--S 293 of 676
Z(i,j) == 1.1*j/40.0+0.7*(1-sin((150-i)*%pi/300))^2
--R                                                                   Type: Void
--E 293
--S 294 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..150,j=0..40,_
           style=="smooth",title=="Gigli")

--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Expression
--R      Float
--I   Compiling function %EX with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %EZ with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %FB with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Gigli"
--R                                               Type: ThreeDimensionalViewport
--E 294
--S 295 of 676
zoom(v3d,2.0,2.0,2.0)
--R                                                                   Type: Void
--E 295
--S 296 of 676
close(v3d)
--R                                                                   Type: Void
--E 296

———-

41 Giglio Ondulato

Identical to gigli but with crenellated edges, giglio ondulato are made of durum-wheat flour and water.

— * —

)clear all
--S 297 of 676
A(i,j) == 0.6+0.03*((40.0-j)/40.0)^10*cos((4*i+75)*%pi/15) - _
          0.5*sin(j*%pi/80)^0.6
--R                                                                   Type: Void
--E 297
--S 298 of 676
B(i,j) == sin(2*i*%pi/75)+(i/150.0)^10*(0.08*sin(j*%pi/40)+0.03*sin(j*%pi/5))
--R                                                                   Type: Void
--E 298

--S 299 of 676
X(i,j) == A(i,j)*cos(2*i*%pi/75)+(i/150.0)^10 * _
          (0.08*sin(j*%pi/40)+0.03*cos(j*%pi/5))
--R                                                                   Type: Void
--E 299
--S 300 of 676
Y(i,j) == (0.6+0.03*((40.0-j)/40.0)^10*sin(4*i*%pi/15)-0.5*sin(j*%pi/80)^0.6)*_
          B(i,j)
--R                                                                   Type: Void
--E 300
--S 301 of 676
Z(i,j) == 1.1*j/40.0+0.7*(1-sin((150.0-i)*%pi/300.0))
--R                                                                   Type: Void
--E 301
--S 302 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..150,j=0..40,_
           style=="smooth",title=="Giglio Ondulato")
--R   Compiling function A with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function B with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Expression
--R      Float
--I   Compiling function %FD with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %FF with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %FH with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (6)  ThreeDimensionalViewport: "Giglio Ondulato"
--R                                               Type: ThreeDimensionalViewport
--E 302
--S 303 of 676
zoom(v3d,2.0,2.0,2.0)
--R                                                                   Type: Void
--E 303
--S 304 of 676
close(v3d)

———-

42 Gnocchetti Sardi

As their name suggests, gnocchetti are simply small gnocchi (or ’dumplings’). They go well with ricotta or Pecorino Romano cheese, or served with thick sauces such as a veal ragu. Gnocchetti originated in Sardinia, a Mediterranean island to the west of Italy.

— * —

)clear all
--S 305 of 676
A(i)   == 0.8+3*sin(i*%pi/150)^0.8
--R                                                                   Type: Void
--E 305
--S 306 of 676
B(i,j) == abs(cos((2*j+7.5)*%pi/15))
--R                                                                   Type: Void
--E 306
--S 307 of 676
X(i,j) == A(i)*cos(i*%pi/50)+0.2*cos(i*%pi/50)*sin(j*%pi/150)*B(i,j)
--R                                                                   Type: Void
--E 307
--S 308 of 676
Y(i,j) == A(i)*sin(i*%pi/50)+0.2*sin(i*%pi/50)*sin(j*%pi/150)*B(i,j)
--R                                                                   Type: Void
--E 308
--S 309 of 676
Z(i,j) == 13.0*cos(j*%pi/150)
--R                                                                   Type: Void
--E 309
--S 310 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..50,j=0..150,_
           style=="smooth",title=="Gnocchetti Sardi")
--R   Compiling function A with type Variable i -> Expression Float
--R   Compiling function B with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression

--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Expression
--R      Float
--I   Compiling function %FI with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %FJ with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %FL with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (6)  ThreeDimensionalViewport: "Gnocchetti Sardi"
--R                                               Type: ThreeDimensionalViewport
--E 310
--S 311 of 676
rotate(v3d,45,45)
--R                                                                   Type: Void
--E 311
--S 312 of 676
close(v3d)
--R                                                                   Type: Void
--E 312

———-

43 Gnocchi

Members of an extended family, gnocchi (dumplings) often resemble a semi-open grooved shell. Their preparation and ingredients (including potato, durum wheat, buckwheat and semolina) vary according to type. Gnocchi are often added to a sauce made from fontina cheese.

— * —

)clear all
--S 313 of 676
A(i,j) == i/40.0*sin(j*%pi/130)
--R                                                                   Type: Void
--E 313
--S 314 of 676
B(i,j) == abs(cos((j+13)*%pi/26))
--R                                                                   Type: Void
--E 314
--S 315 of 676

X(i,j) == 0.2*cos(i*1.3*%pi/40)*sin(j*%pi/130)*B(i,j) + _
          A(i,j)*cos(i*1.3*%pi/40)
--R                                                                   Type: Void
--E 315
--S 316 of 676
Y(i,j) == 0.2*sin(i*1.3*%pi/40)*sin(j*%pi/130)*B(i,j) + _
          A(i,j)*sin(i*1.3*%pi/40)
--R                                                                   Type: Void
--E 316
--S 317 of 676
Z(i,j) == 1.5*cos(j*%pi/130)
--R                                                                   Type: Void
--E 317
--S 318 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..40,j=0..130,_
           style=="smooth",title=="Gnocchi")
--R   Compiling function B with type (Variable i,Variable j) -> Expression
--R      Integer
--R   Compiling function A with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Expression
--R      Float
--I   Compiling function %FM with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %FN with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %FP with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (6)  ThreeDimensionalViewport: "Gnocchi"
--R                                               Type: ThreeDimensionalViewport
--E 318
--S 319 of 676
close(v3d)
--R                                                                   Type: Void
--E 319

———-

44 Gramigna

A speciality of the northern Italian region of Emilia-Romagna, gramigna (little weed) are traditionally served with a chunky sauce of sausages, or accompanied by the world-famous ragu alla bolognese. Alternatively, gramigna are sometimes presented alla pomodoro (with a light tomato sauce).

— * —

)clear all
--S 320 of 676
X(i,j) == (0.5+5.6*(j/150.0)^2+0.3*cos(2*i*%pi/25))*cos(2.1*j*%pi/150)
--R                                                                   Type: Void
--E 320
--S 321 of 676
Y(i,j) == 0.3*sin(2*i*%pi/25)
--R                                                                   Type: Void
--E 321
--S 322 of 676
Z(i,j) == (0.5+3.2*(j/150.0)^2+0.3*cos(2*i*%pi/25))*sin(2.1*j*%pi/150)
--R                                                                   Type: Void
--E 322
--S 323 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..25,j=0..150,_
           style=="smooth",title=="Gramigna")
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Expression
--R      Float
--I   Compiling function %FR with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %FT with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %FV with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Gramigna"
--R                                               Type: ThreeDimensionalViewport
--E 323
--S 324 of 676
zoom(v3d,2.0,2.0,2.0)
--R                                                                   Type: Void
--E 324

--S 325 of 676
close(v3d)
--R                                                                   Type: Void
--E 325

———-

45 Lancette

No longer than 15mm, lancette or ’hands’ (of a clock) belong to the postine minute (tiny pasta) clan. They are delicious in consommes with a sprinkling of croutons and chopped greens. Lancette are also an excellent addition to mushroom or chicken soups.

— * —

)clear all
--S 326 of 676
A(i,j) == 0.4*sin(5*j*%pi/9)
--R                                                                   Type: Void
--E 326
--S 327 of 676
B(i,j) == sin((j+45)*%pi/90)
--R                                                                   Type: Void
--E 327
--S 328 of 676
C(i,j) == (3.0*i-75.0)/5.0*sin(j*%pi/90)-(1-sin(i*%pi/50))^25*A(i,j)*B(i,j)
--R                                                                   Type: Void
--E 328
--S 329 of 676
D(i,j) == _
  if (i <= 25) _
   then C(i,j) _
   else 30.0*(i-25.0)/50.0*sin(j*%pi/90)+sin((i-25)*%pi/50)*A(i,j)*B(i,j)
--R                                                                   Type: Void
--E 329
--S 330 of 676
X(i,j) == 4*cos(3*D(i,j)*%pi/50)
--R                                                                   Type: Void
--E 330
--S 331 of 676
Y(i,j) == 4*sin(3*D(i,j)*%pi/50)*(0.3+(1-sin(j*%pi/90))^0.6)
--R                                                                   Type: Void

--E 331
--S 332 of 676
Z(i,j) == j/3.0
--R                                                                   Type: Void
--E 332
--S 333 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..50,j=0..90,_
           style=="smooth",title=="Lancette")
--R   Compiling function A with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function B with type (Variable i,Variable j) -> Expression
--R      Integer
--R   Compiling function C with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function D with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Polynomial
--R      Float
--I   Compiling function %FX with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %FZ with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %GB with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (8)  ThreeDimensionalViewport: "Lancette"
--R                                               Type: ThreeDimensionalViewport
--E 333
--S 334 of 676
zoom(v3d,3.0,3.0,3.0)
--R                                                                   Type: Void
--E 334
--S 335 of 676
close(v3d)
--R                                                                   Type: Void
--E 335

———-

46 Lasagna Larga Doppia Riccia

As their name suggests, lasagna larga doppia riccia (large doubly curled lasagna) have two long undulating edges. The curls give the pasta a variable consistency when cooked, and help them to collect sauce. Lasagne are excellent with ricotta and a ragu napoletano, or cooked al forno (at the oven) with a creamy besciamella sauce.

— * —

)clear all
--S 336 of 676
X(i,j) == _
  if ((8 <= i) and (i <= 42)) _
   then 5.0/6.0+(5.0*i-40.0)/34.0 _
   else if (i <= 8) _
         then 5.0*i/48.0 _
         else 5.0/6.0*(7+(i-42.0)/8)
--R                                                                   Type: Void
--E 336
--S 337 of 676
Y(i,j) == j/15.0
--R                                                                   Type: Void
--E 337
--S 338 of 676
Z(i,j) == _
  if ((8 <= i) and (i <= 42)) _
   then 0.0 _
   else if (i <= 8) _
         then (8.0-i)/32.0*cos((j+3)*%pi/6) _
         else 0.25*(i-42)/8.0*cos((j+9)*%pi/6)
--R                                                                   Type: Void
--E 338
--S 339 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..50,j=0..150,_
           style=="smooth",title=="Lasagna Larga Doppia Riccia")
--R   Compiling function X with type (Variable i,Variable j) -> Polynomial
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Polynomial
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Expression
--R      Float
--I   Compiling function %GD with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %GF with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %GH with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat

--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Lasagna Larga Doppia Riccia"
--R                                               Type: ThreeDimensionalViewport
--E 339
--S 340 of 676
zoom(v3d,3.0,3.0,3.0)
--R                                                                   Type: Void
--E 340
--S 341 of 676
close(v3d)
--R                                                                   Type: Void
--E 341

———-

47 Linguine

The thinnest member of the bavette (little dribble) family, linguine (little tongues) are best accompanied by fresh tomato, herbs, a drop of olive oil, garlic, anchovies, and hot peppers. Linguine may also be served with shellfish sauces, or white sauces of cream and soft cheese, flavoured with lemon, saffron, or ginger.

— * —

)clear all
--S 342 of 676
X(i,j) == cos(i*%pi/75)
--R                                                                   Type: Void
--E 342
--S 343 of 676
Y(i,j) == 2*sin(i*%pi/75)
--R                                                                   Type: Void
--E 343
--S 344 of 676
Z(i,j) == j/5.0
--R                                                                   Type: Void
--E 344
--S 345 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..150,j=0..50,_
           style=="smooth",title=="Linguine")
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Integer

--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Integer
--R   Compiling function Z with type (Variable i,Variable j) -> Polynomial
--R      Float
--I   Compiling function %GJ with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %GL with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %GN with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Linguine"
--R                                               Type: ThreeDimensionalViewport
--E 345
--S 346 of 676
zoom(v3d,2.5,2.5,2.5)
--R                                                                   Type: Void
--E 346
--S 347 of 676
close(v3d)
--R                                                                   Type: Void
--E 347

———-

48 Lumaconi Rigati

Originally from Campania and Liguria, lumaconi rigati (big ribbed snails) can be stuffed with a wide range of fillings, including spinach and ricotta cheese. Like cannelloni, they can then be covered in besciamella and cooked in the oven. Smaller members of the family (lumache) are also available.

— * —

)clear all
--S 348 of 676
A(i,j) == 0.45+0.01*cos(i*%pi/3)+j/300.0*abs(cos(i*%pi/240))*cos(i*%pi/120)^20
--R                                                                   Type: Void
--E 348
--S 349 of 676
B(i,j) == j/300.0*abs(cos(i*%pi/240))*sin(i*%pi/120) + _
          0.125*(j/60.0)^6*sin(i*%pi/120)
--R                                                                   Type: Void
--E 349

--S 350 of 676
X(i,j) == (0.4*cos(i*%pi/120)+A(i,j))*cos(j*%pi/60) + _
          0.48*(j/60.0)^6*sin((i+60)*%pi/120)^3
--R                                                                   Type: Void
--E 350
--S 351 of 676
Y(i,j) == 0.5*sin(i*%pi/120)+0.01*sin(i*%pi/3)+B(i,j)
--R                                                                   Type: Void
--E 351
--S 352 of 676
Z(i,j) == (0.45+0.4*cos(i*%pi/120))*sin(j*%pi/60)
--R                                                                   Type: Void
--E 352
--S 353 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..240,j=0..60,_
           style=="smooth",title=="Lumaconi Rigati")
--R   Compiling function A with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function B with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Expression
--R      Float
--I   Compiling function %GO with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %GP with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %GR with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (6)  ThreeDimensionalViewport: "Lumaconi Rigati"
--R                                               Type: ThreeDimensionalViewport
--E 353
--S 354 of 676
rotate(v3d,90,180)
--R                                                                   Type: Void
--E 354
--S 355 of 676
close(v3d)
--R                                                                   Type: Void

--E 355

———-

49 Maccheroni

The origin of the name maccheroni is uncertain. It is used generically to describe a hollow pasta corta (short pasta) that is moade of durum-wheat flour and perhasp eggs. The pasta can be served con le sarde (with sardines) - a dish enhanced by a touch of fennel.

— * —

)clear all
--S 356 of 676
X(i,j) == 8*cos(i*%pi/75)+0.2*cos(4*i*%pi/15)+5*cos(j*%pi/100)
--R                                                                   Type: Void
--E 356
--S 357 of 676
Y(i,j) == 8*sin(i*%pi/75)+0.2*sin(4*i*%pi/15)+4*sin(j*%pi/100)
--R                                                                   Type: Void
--E 357
--S 358 of 676
Z(i,j) == 6.0*j/5.0
--R                                                                   Type: Void
--E 358
--S 359 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..150,j=0..50,_
           style=="smooth",title=="Maccheroni")
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Polynomial
--R      Float
--I   Compiling function %GT with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %GV with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %GX with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Maccheroni"
--R                                               Type: ThreeDimensionalViewport
--E 359

--S 360 of 676
zoom(v3d,2.0,2.0,2.0)
--R                                                                   Type: Void
--E 360
--S 361 of 676
close(v3d)
--R                                                                   Type: Void
--E 361

———-

50 Maccheroni Alla Chitarra

Coming from the central Italian region of Abruzzo, maccheroni alla chitarra (guitar maccheroni) have a square cross-section, produced when a thin sheet of pasta is pressed through a frame of closely ranged wires (or chitarra) that lends the pasta its name. Usually seved with a mutton ragu, or pallottelle (veal meatballs).

— * —

)clear all
--S 362 of 676
X(i,j) == 0.05*cos(i*%pi/60)^3 + 0.05*cos(i*%pi/60)
--R                                                                   Type: Void
--E 362
--S 363 of 676
Y(i,j) == 0.05*sin(i*%pi/60)^3 + 0.05*sin(i*%pi/60)
--R                                                                   Type: Void
--E 363
--S 364 of 676
Z(i,j) == j/60.0
--R                                                                   Type: Void
--E 364
--S 365 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..120,j=0..60,_
           style=="smooth",title=="Maccheroni Alla Chitarra")
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Polynomial
--R      Float
--I   Compiling function %GZ with type (DoubleFloat,DoubleFloat) ->

--R      DoubleFloat
--I   Compiling function %HB with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %HD with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Maccheroni Alla Chitarra"
--R                                               Type: ThreeDimensionalViewport
--E 365
--S 366 of 676
zoom(v3d,2.5,2.5,2.5)
--R                                                                   Type: Void
--E 366
--S 367 of 676
close(v3d)
--R                                                                   Type: Void
--E 367

———-

51 Mafaldine

Named at the turn of the twentieth century after Princess Mafalda of the House of Savoy, mafaldine are thin flat sheets of durum-wheat flour pasta with a rippled finish on each long edge. They are generally served with meaty sauces such as ragu napoletano or in seafood dishes.

— * —

)clear all
--S 368 of 676
X(i,j) == 7.0*i/18.0
--R                                                                   Type: Void
--E 368
--S 369 of 676
Y(i,j) == j/3.0
--R                                                                   Type: Void
--E 369
--S 370 of 676
Z(i,j) == _
  if ((6 <= i) and (i <= 24)) _
   then 0.0 _
   else if (i <= 6) _

         then (6.0-i)/6.0*cos((j+5)*%pi/10) _
         else (i-24.0)/6.0*cos((j+15)*%pi/10)
--R                                                                   Type: Void
--E 370
--S 371 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..30,j=0..150,_
           style=="smooth",title=="Mafaldine")
--R   Compiling function X with type (Variable i,Variable j) -> Polynomial
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Polynomial
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Expression
--R      Float
--I   Compiling function %HF with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %HH with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %HJ with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Mafaldine"
--R                                               Type: ThreeDimensionalViewport
--E 371
--S 372 of 676
zoom(v3d,2.0,2.0,2.0)
--R                                                                   Type: Void
--E 372
--S 373 of 676
close(v3d)
--R                                                                   Type: Void
--E 373

———-

52 Manicotti

One of the oldest-known durum-wheat varieties, manicotti (sleeves) were originally prepared by cutting dough into rectangles, which were topped with stuffing, rolled and finally baked al forno (at the oven). Today they are served containing a variety of cheeses and covered in a savoury sauce, like filled dinner crepes.

— * —

)clear all

--S 374 of 676
A(i,j) == -7*sin((i-100)*%pi/100)^2+0.3*sin((3*i-300)*%pi/10)
--R                                                                   Type: Void
--E 374
--S 375 of 676
B(i,j) == -8*cos((i-100)*%pi/100)+0.3*cos((3*i-300)*%pi/10)
--R                                                                   Type: Void
--E 375
--S 376 of 676
C(i,j) == -8*cos((i-100)*%pi/100)+22*sin((j-20)*%pi/40)
--R                                                                   Type: Void
--E 376
--S 377 of 676
X(i,j) == _
  if (i < 100) _
   then 7*sin(i*%pi/100)^2+0.3*sin(3*i*%pi/10) _
   else A(i,j)
--R                                                                   Type: Void
--E 377
--S 378 of 676
Y(i,j) == _
  if (i < 100) _
   then 8*cos(i*%pi/100)+0.3*cos(3*i*%pi/10) _
   else B(i,j)
--R                                                                   Type: Void
--E 378
--S 379 of 676
Z(i,j) == _
  if (i < 100) _
   then 8*cos(i*%pi/100)+22*sin((j-20)*%pi/40) _
   else C(i,j)
--R                                                                   Type: Void
--E 379
--S 380 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..200,j=0..40,_
           style=="smooth",title=="Manicotti")
--R   Compiling function A with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function B with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float

--R   Compiling function C with type (Variable i,Variable j) -> Expression
--R      Integer
--R   Compiling function Z with type (Variable i,Variable j) -> Expression
--R      Integer
--I   Compiling function %HL with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %HN with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %HP with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (7)  ThreeDimensionalViewport: "Manicotti"
--R                                               Type: ThreeDimensionalViewport
--E 380
--S 381 of 676
zoom(v3d,1.5,1.5,1.5)
--R                                                                   Type: Void
--E 381
--S 382 of 676
close(v3d)
--R                                                                   Type: Void
--E 382

———-

53 Orecchiette

This pasta is popular in the southeastern coastal region of Puglia in Italy, where it is customarily cooked in dishes with rapini, a relative of broccoli that grows plentifully in the area. Orecchiette (litte ears) also pair well with other vegetables such as beans, and with salty seasonings such as anchovies, capers, or olives.

— * —

)clear all
--S 383 of 676
X(i,j) == 2.0*j/3.0*cos(i*%pi/75)+0.3*cos(2*i*%pi/15)
--R                                                                   Type: Void
--E 383
--S 384 of 676
Y(i,j) == 10*sin(i*%pi/75)
--R                                                                   Type: Void
--E 384

--S 385 of 676
Z(i,j) == 0.1*cos(i*%pi/3)+5*(0.5+0.5*cos(2*i*%pi/75))^4*cos(j*%pi/30)^2 + _
          1.5*(0.5+0.5*cos(2*i*%pi/75))^5*sin(j*%pi/30)^10
--R                                                                   Type: Void
--E 385
--S 386 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..150,j=0..15,_
           style=="smooth",title=="Orecchiette")
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Integer
--R   Compiling function Z with type (Variable i,Variable j) -> Expression
--R      Float
--I   Compiling function %HR with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %HT with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %HV with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Orecchiette"
--R                                               Type: ThreeDimensionalViewport
--E 386
--S 387 of 676
close(v3d)
--R                                                                   Type: Void
--E 387

———-

54 Paccheri

Part of the pasta corta (short pasta) family, paccheri are ribbed pasta cylinders that (due to their large size) are recommended with aubergine, seafood, or indeed any chunky sauce. It is thought the name stems from the term paccare, which means ’to smack’ in the southern Italian region of Campania.

— * —

)clear all
--S 388 of 676
X(i,j) == (j+60.0)/60.0*cos(i*%pi/75)+0.5*cos(j*%pi/60)+cos((i+j)*%pi/75)
--R                                                                   Type: Void
--E 388

--S 389 of 676
Y(i,j) == 2.6*sin(i*%pi/75)+0.3*sin(j*%pi/60)
--R                                                                   Type: Void
--E 389
--S 390 of 676
Z(i,j) == 7.0*j/30.0
--R                                                                   Type: Void
--E 390
--S 391 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..150,j=0..30,_
           style=="smooth",title=="Paccheri")
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Polynomial
--R      Float
--I   Compiling function %HX with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %HZ with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %IB with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Paccheri"
--R                                               Type: ThreeDimensionalViewport
--E 391
--S 392 of 676
close(v3d)
--R                                                                   Type: Void
--E 392

———-

55 Pappardelle

This pasta lunga (long pasta) is often cooked with duck, pigeon, or other game fowl. Pappardelle are so popular that towns in Italy hold festivals in their honour, such as the Sagra delle Pappardelle al Cinghiale (Feast of the Pappardelle and Boar) in Torre Alfina, central Italy.

— * —

)clear all

--S 393 of 676
A(i,j) == cos(i*%pi/80)+(3.0*j)/50.0*sin(21*i*%pi/800)
--R                                                                   Type: Void
--E 393
--S 394 of 676
B(i,j) == sin(i*%pi/3200)^0.1*sin(i*%pi/80)
--R                                                                   Type: Void
--E 394
--S 395 of 676
C(i,j) == 3.0*j/50.0+0.5*sin(i*%pi/200)
--R                                                                   Type: Void
--E 395
--S 396 of 676
D(i,j) == cos(i*%pi/80)+3.0*j/50.0*sin(21*i*%pi/800)
--R                                                                   Type: Void
--E 396
--S 397 of 676
E(i,j) == sin(i*%pi/3200)^0.5*sin(i*%pi/80)
--R                                                                   Type: Void
--E 397
--S 398 of 676
F(i,j) == 3.0*j/50.0+0.5*sin(i*%pi/200)
--R                                                                   Type: Void
--E 398
--S 399 of 676
vsp:=createThreeSpace()
--R
--R   (7)  3-Space with 0 components
--R                                                 Type: ThreeSpace DoubleFloat
--E 399
--S 400 of 676
makeObject(surface(A(i,j),B(i,j),C(i,j)),i=0..800,j=0..5,space==vsp)
--R   Compiling function A with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function B with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function C with type (Variable i,Variable j) -> Expression
--R      Float
--I   Compiling function %ID with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %IF with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat

--I   Compiling function %IH with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R
--R   (8)  3-Space with 1 component
--R                                                 Type: ThreeSpace DoubleFloat
--E 400
--S 401 of 676
makeObject(surface(0.6*D(i,j),0.8*E(i,j),0.9*F(i,j)),i=0..800,j=0..5,_
           space==vsp)
--R   Compiling function D with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function E with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function F with type (Variable i,Variable j) -> Expression
--R      Float
--I   Compiling function %IJ with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %IL with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %IN with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R
--R   (9)  3-Space with 2 components
--R                                                 Type: ThreeSpace DoubleFloat
--E 401
--S 402 of 676
vp:=makeViewport3D(vsp,style=="smooth",title=="Pappardelle")
--R   Transmitting data...
--R
--R   (10)  ThreeDimensionalViewport: "Pappardelle"
--R                                               Type: ThreeDimensionalViewport
--E 402
--S 403 of 676
close(vp)
--R                                                                   Type: Void
--E 403

———-

56 Penne Rigate

A versatile pasta, penne rigate (grooved quills) come from Campania, in southern Italy, and belong to the pasta corta (short pasta) family. they can be served with spicy arrabbiata (angry) sauce, which gets its name from the chillies and red peppers it contains.

— * —

--S 404 of 676
X(i,j) == _
  if (i < 85) _
   then 4*sin(i*%pi/85)^2+0.1*sin(6*i*%pi/17) _
   else -4*sin((i-85)*%pi/85)^2+0.1*sin(6*(i-85)*%pi/17)
--R                                                                   Type: Void
--E 404
--S 405 of 676
Y(i,j) == _
  if (i < 85) _
   then 4*cos(i*%pi/85)+0.1*cos(6*i*%pi/17) _
   else -4*cos((i-85)*%pi/85)+0.1*cos(6*(i-85)*%pi/17)
--R                                                                   Type: Void
--E 405
--S 406 of 676
Z(i,j) == _
  if (i < 85) _
   then 7*cos(i*%pi/85)+15*sin((j-20)*%pi/40) _
   else -7*cos((i-85)*%pi/85)+15*sin((j-20)*%pi/40)
--R                                                                   Type: Void
--E 406
--S 407 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..170,j=0..40,_
           style=="smooth",title=="Penne Rigate")
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Expression
--R      Integer
--I   Compiling function %IP with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %IR with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %IT with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Penne Rigate"
--R                                               Type: ThreeDimensionalViewport
--E 407
--S 408 of 676
close(v3d)
--R                                                                   Type: Void

--E 408

———-

57 Pennoni Lisci

Similar in appearance to penne rigate, but larger and without the grooves, pennoni (large quills) require a more oily sauce (perhaps containing sliced chorizo) to cling to their smooth surface.

— * —

)clear all
--S 409 of 676
X(i,j) == _
  if (i < 100) _
   then 7*sin(i*%pi/100)^2 _
   else -7*sin((i-100)*%pi/100)^2
--R                                                                   Type: Void
--E 409
--S 410 of 676
Y(i,j) == _
  if (i < 100) _
   then 8*cos(i*%pi/100) _
   else -8*cos((i-100)*%pi/100)
--R                                                                   Type: Void
--E 410
--S 411 of 676
Z(i,j) == _
  if (i < 100) _
   then 12*cos(i*%pi/100)+15*sin((j-20)*%pi/40) _
   else -12*cos((i-100)*%pi/100)+15*sin((j-20)*%pi/40)
--R                                                                   Type: Void
--E 411
--S 412 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..200,j=0..40,_
           style=="smooth",title=="Pennoni Lisci")
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Integer
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Integer
--R   Compiling function Z with type (Variable i,Variable j) -> Expression
--R      Integer
--I   Compiling function %IU with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat

--I   Compiling function %IV with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %IW with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Pennoni Lisci"
--R                                               Type: ThreeDimensionalViewport
--E 412
--S 413 of 676
close(v3d)
--R                                                                   Type: Void
--E 413

———-

58 Pennoni Rigati

The angled trim of the penne pasta family makes its members easy to recognize. Pennoni rigati (large grooved quills) are the ridged version of pennoni, and can be stuffed and cooked.

— * —

)clear all
--S 414 of 676
A(i,j) == -7*sin((i-100)*%pi/100)^2+0.2*sin((3*i-300)*%pi/10)
--R                                                                   Type: Void
--E 414
--S 415 of 676
B(i,j) == -8*cos((i-100)*%pi/100)+0.2*cos((3*i-300)*%pi/10)
--R                                                                   Type: Void
--E 415
--S 416 of 676
C(i,j) == -12*cos((i-100)*%pi/100)+15*sin((j-20)*%pi/40)
--R                                                                   Type: Void
--E 416
--S 417 of 676
X(i,j) == _
  if (i < 100) _
   then 7*sin(i*%pi/100)^2+0.15*sin(3*i*%pi/10) _
   else A(i,j)
--R                                                                   Type: Void
--E 417

--S 418 of 676
Y(i,j) == _
  if (i < 100) _
   then 8*cos(i*%pi/100)+0.15*cos(3*i*%pi/10) _
   else B(i,j)
--R                                                                   Type: Void
--E 418
--S 419 of 676
Z(i,j) == _
  if (i < 100) _
   then 12*cos(i*%pi/100)+15*sin((j-20)*%pi/40) _
   else C(i,j)
--R                                                                   Type: Void
--E 419
--S 420 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..200,j=0..40,_
           style=="smooth",title=="Pennoni Rigati")
--R   Compiling function A with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function B with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function C with type (Variable i,Variable j) -> Expression
--R      Integer
--R   Compiling function Z with type (Variable i,Variable j) -> Expression
--R      Integer
--I   Compiling function %IY with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %JA with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %JC with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (7)  ThreeDimensionalViewport: "Pennoni Rigati"
--R                                               Type: ThreeDimensionalViewport
--E 420
--S 421 of 676
close(v3d)
--R                                                                   Type: Void
--E 421

———-

59 Puntalette

Another member of the pastine minute (tiny pasta) family, puntalette (tiny tips) are about 9 mm long, and no thicker than 3 mm. Like most pastine, they are best consumed in creamy soups, or perhaps in a salad.

— * —

)clear all
--S 422 of 676
X(i,j) == 1.4*sin(j*%pi/80)^1.2*cos(i*%pi/40)
--R                                                                   Type: Void
--E 422
--S 423 of 676
Y(i,j) == 2.5*sin(j*%pi/80)^1.2*sin(i*%pi/40)
--R                                                                   Type: Void
--E 423
--S 424 of 676
Z(i,j) == 8*cos(j*%pi/80)
--R                                                                   Type: Void
--E 424
--S 425 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..80,j=0..80,_
           style=="smooth",title=="Puntalette")
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Expression
--R      Integer
--I   Compiling function %JE with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %JG with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %JI with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Puntalette"
--R                                               Type: ThreeDimensionalViewport
--E 425
--S 426 of 676
close(v3d)
--R                                                                   Type: Void
--E 426

60 Quadrefiore

An uncommon variety of pasta corta (short pasta), quadrefiori (square flowers) are sturdy, with rippled edges running down their lengths. Francis Ford Coppola, the maker and distributor, uses antique bronze moulds and wooden drying racks to achieve an authentic form and consistency.

— * —

)clear all
--S 427 of 676
X(i,j) == 2*cos(i*%pi/250)*(abs(sin(3*i*%pi/250)))^20 + _
          (0.6+0.9*sin(j*%pi/50))*cos(i*%pi/250)+0.2*cos(4*j*%pi/25)
--R                                                                   Type: Void
--E 427
--S 428 of 676
Y(i,j) == 2*sin(i*%pi/250)*(abs(sin(3*i*%pi/250)))^20 + _
          (0.6+0.9*sin(j*%pi/50))*sin(i*%pi/250)+1.5*sin(j*%pi/50)
--R                                                                   Type: Void
--E 428
--S 429 of 676
Z(i,j) == 3.0*j/10.0
--R                                                                   Type: Void
--E 429
--S 430 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..500,j=0..50,_
           style=="smooth",title=="Quadrefiore")
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Polynomial
--R      Float
--I   Compiling function %JJ with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %JK with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %JM with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Quadrefiore"
--R                                               Type: ThreeDimensionalViewport
--E 430

--S 431 of 676
zoom(v3d,2.0,2.0,2.0)
--R                                                                   Type: Void
--E 431
--S 432 of 676
close(v3d)
--R                                                                   Type: Void
--E 432

———-

61 Quadretti

These flat shapes are made with durum-wheat flour, eggs, and even nutmeg. Quadretti (tiny squares) are a classic pastine prepared using the leftovers of larger pasta sheets, and can be served as part of a traditional fish broth, or in soups containing fava beans. Their small shape means that they need only be cooked for a short time.

— * —

)clear all
--S 433 of 676
X(i,j) == 3.0*i/14.0
--R                                                                   Type: Void
--E 433
--S 434 of 676
Y(i,j) == 3.0*j/14.0
--R                                                                   Type: Void
--E 434
--S 435 of 676
Z(i,j) == 0.0
--R                                                                   Type: Void
--E 435
--S 436 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..70,j=0..70,_
           style=="smooth",title=="Quadretti")
--R   Compiling function X with type (Variable i,Variable j) -> Polynomial
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Polynomial
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Float
--I   Compiling function %JO with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat

--I   Compiling function %JQ with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %JS with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Quadretti"
--R                                               Type: ThreeDimensionalViewport
--E 436
--S 437 of 676
close(v3d)
--R                                                                   Type: Void
--E 437

———-

62 Racchette

Usually served in salads, racchette (rackets) suit crunchy pine nuts, sliced asparagus and fresh peas. Alternatively, the addition of diced watermelon or pomegranate seeds can create a light-tasking snack.

— * —

)clear all
--S 438 of 676
A(i)    == sin(i*%pi/2000)^0.5
--R                                                                   Type: Void
--E 438
--S 439 of 676
X0(i,j) == 2*cos((i+1500)*%pi/1500)+0.65*cos((i+750)*%pi/1500) + _
           2*(abs(cos(i*%pi/300)))^100*cos(i*%pi/1500)
--R                                                                   Type: Void
--E 439
--S 440 of 676
Y0(i,j) == 2.4*sin((i+1500)*%pi/1500)+0.1*sin(i*%pi/1500) + _
           2.3*(abs(sin(i*%pi/300)))^100*sin(i*%pi/1500)
--R                                                                   Type: Void
--E 440
--S 441 of 676
X1(i,j) == _
  if (i <= 2000) _
   then 2.1*cos((2*A(i)+1)*%pi)+0.65*cos((2*A(i)+0.5)*%pi)+_
        2.5*sin((A(i)+1.83)*%pi)^500 _

   else -2.1
--R                                                                   Type: Void
--E 441
--S 442 of 676
Y1(i,j) == _
  if (i <= 2000) _
   then 2.5*sin((2*A(i)+1)*%pi)+0.1*sin(A(i)*2*%pi)+_
        3*sin((A(i)+1.83)*%pi)^500 _
   else 0.0
--R                                                                   Type: Void
--E 442
--S 443 of 676
Z(i,j) == j/4.0
--R                                                                   Type: Void
--E 443
--S 444 of 676
vsp:=createThreeSpace()
--R
--R   (7)  3-Space with 0 components
--R                                                 Type: ThreeSpace DoubleFloat
--E 444
--S 445 of 676
makeObject(surface(X0(i,j),Y0(i,j),Z(i,j)),i=0..3000,j=0..4,space==vsp)
--R   Compiling function X0 with type (Variable i,Variable j) ->
--R      Expression Float
--R   Compiling function Y0 with type (Variable i,Variable j) ->
--R      Expression Float
--R   Compiling function Z with type (Variable i,Variable j) -> Polynomial
--R      Float
--I   Compiling function %JT with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %JU with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %JW with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R
--R   (8)  3-Space with 1 component
--R                                                 Type: ThreeSpace DoubleFloat
--E 445
--S 446 of 676
makeObject(surface(X0(i,j),Y0(i,j),Z(i,j)),i=0..3000,j=0..4,space==vsp)
--I   Compiling function %JX with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %JY with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat

--I   Compiling function %KA with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R
--R   (9)  3-Space with 2 components
--R                                                 Type: ThreeSpace DoubleFloat
--E 446
--S 447 of 676
vp:=makeViewport3D(vsp,style=="smooth",title=="Racchette")
--R   Transmitting data...
--R
--R   (10)  ThreeDimensionalViewport: "Racchette"
--R                                               Type: ThreeDimensionalViewport
--E 447
--S 448 of 676
close(vp)
--R                                                                   Type: Void
--E 448

———-

63 Radiatori

Small and squat, radiatori (radiators) are named after their ruffled edge When boiled, drained, and served as a pastasciutta their open centre and large surface area holds thick sauces well, while the flaps sweep up and trap smaller morsels of food. This pasta is often accompanied by a lamb-, veal-, rabbit-, or pork-based ragu.

— * —

)clear all
--S 449 of 676
X(i,j) == (1.5+3*(i/70.0)^5+4*sin(j*%pi/200)^50)*cos(4*i*%pi/175)
--R                                                                   Type: Void
--E 449
--S 450 of 676
Y(i,j) == (1.5+3*(i/70.0)^5+4*sin(j*%pi/200)^50)*sin(4*i*%pi/175)
--R                                                                   Type: Void
--E 450
--S 451 of 676
Z(i,j) == j/50.0+cos(3*i*%pi/14)*sin(j*%pi/1000)
--R                                                                   Type: Void
--E 451
--S 452 of 676

v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..70,j=0..1000,_
           style=="smooth",title=="Radiatori")
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Expression
--R      Float
--I   Compiling function %KC with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %KE with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %KG with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Radiatori"
--R                                               Type: ThreeDimensionalViewport
--E 452
--S 453 of 676
zoom(v3d,2.0,2.0,2.0)
--R                                                                   Type: Void
--E 453
--S 454 of 676
close(v3d)
--R                                                                   Type: Void
--E 454

———-

64 Ravioli Quadrati

Except for the square outline, ravioli quadrati (square ravioli) are made in an identical fashion to ravioli tondi (round ravioli). Other variations on the theme include crescents, triangles, and hearts. Some suggest the name ravioli derives from the verb meaning ’to wrap’, others link it with rapa, the Italian word for turnip.

— * —

)clear all
--S 455 of 676
X(i,j) == i/2.0+0.4*sin((j+2.5)*%pi/5) * _
          (sin(i*%pi/200)^0.2 - cos(i*%pi/200)^0.2)
--R                                                                   Type: Void
--E 455

--S 456 of 676
Y(i,j) == j/2.0+0.4*sin((11*i+25)*%pi/50) * _
          (sin(j*%pi/200)^0.2 - cos(j*%pi/200)^0.2)
--R                                                                   Type: Void
--E 456
--S 457 of 676
Z(i,j) == _
  if (((10 < j) and (j < 90)) or ((10 < i) and (i < 90))) _
   then 10*sin((i-10)*%pi/80)^0.6*sin((j-10)*%pi/80)^0.6 _
   else if ((10 > j) or (10 > i)) _
         then 0.0 _
         else 0.0
--R                                                                   Type: Void
--E 457
--S 458 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..99,j=0..99,_
           style=="smooth",title=="Ravioli Quadrati")
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Expression
--R      Float
--I   Compiling function %KI with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %KK with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %KM with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Ravioli Quadrati"
--R                                               Type: ThreeDimensionalViewport
--E 458
--S 459 of 676
close(v3d)
--R                                                                   Type: Void
--E 459

———-

65 Ravioli Tondi

By far the best-known pasta ripiena (filled pasta), ravioli tondi (round ravioli) are made by sealing a filling between two layers of dough made from wheat flour and egg. Fillings vary enormously, from lavish pairings of meat and cheese, to more deleicate centres of mushrooms, spinach, or even nettle.

— * —

)clear all
--S 460 of 676
X(i,j) == 5.0*i/8.0+0.5*sin((j+2)*%pi/4) * _
          (sin(i*%pi/160)^0.2-cos(i*%pi/160)^0.2)
--R                                                                   Type: Void
--E 460
--S 461 of 676
Y(i,j) == 5.0*j/8.0+0.5*sin((i+2)*%pi/4) * _
          (sin(j*%pi/160)^0.2-cos(j*%pi/160)^0.2)
--R                                                                   Type: Void
--E 461
--S 462 of 676
Z(i,j) == _
  if (600 >= ((i-40)^2+(j-40)^2)) _
   then 0.5*sqrt(600 - (i-40)^2-(j-40)^2) _
   else 0.0
--R                                                                   Type: Void
--E 462
--S 463 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..80,j=0..80,_
           style=="smooth",title=="Ravioli Tondi")
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Expression
--R      Float
--I   Compiling function %KO with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %KQ with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %KS with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Ravioli Tondi"
--R                                               Type: ThreeDimensionalViewport
--E 463
--S 464 of 676
close(v3d)
--R                                                                   Type: Void

--E 464

———-

66 Riccioli

A well-know pasta corta (short pasta), riccioli (curls) originated in the Emilia-Romagna region of northern Italy. Their ribbed exterior and hollow shape mean riccioli can retain a large quantity of sauce.

— * —

)clear all
--S 465 of 676
X(i,j) == (2+8*sin(i*%pi/100)+9*sin((11*j+100)*%pi/400)^2)*cos(4*i*%pi/125)
--R                                                                   Type: Void
--E 465
--S 466 of 676
Y(i,j) == (2+8*sin(i*%pi/100)+9*sin((11*j+100)*%pi/400)^2)*sin(4*i*%pi/125)
--R                                                                   Type: Void
--E 466
--S 467 of 676
Z(i,j) == j/4.0
--R                                                                   Type: Void
--E 467
--S 468 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..50,j=0..200,_
           style=="smooth",title=="Riccioli")
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Integer
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Integer
--R   Compiling function Z with type (Variable i,Variable j) -> Polynomial
--R      Float
--I   Compiling function %KU with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %KW with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %KY with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Riccioli"
--R                                               Type: ThreeDimensionalViewport
--E 468

--S 469 of 676
zoom(v3d,2.0,2.0,2.0)
--R                                                                   Type: Void
--E 469
--S 470 of 676
close(v3d)
--R                                                                   Type: Void
--E 470

———-

67 Riccioli al Cinque Sapori

Riccioli and riccioli al cinque sapori (curls in five flavors) are both members of the pasta corta (small pasta) family, without being related by structural similarities. Made of durum-wheat flour, riccioli al cinque sapori get their color from the addition of spinach, tomato, beetroot, and turmeric, and are usually served in broth.

— * —

)clear all
--S 471 of 676
X(i,j) == 1.5*cos(i*%pi/20)*(1+0.5*sin(j*%pi/25)*sin(i*%pi/40) + _
          0.43*sin((j+18.75)*%pi/25)*cos(i*%pi/40))+2*cos(j*%pi/50)
--R                                                                   Type: Void
--E 471
--S 472 of 676
Y(i,j) == 1.5*sin(i*%pi/20)^3+cos(j*%pi/25)
--R                                                                   Type: Void
--E 472
--S 473 of 676
Z(i,j) == sin(j*%pi/100)+20*cos(j*%pi/200)^2
--R                                                                   Type: Void
--E 473
--S 474 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..20,j=0..100,_
           style=="smooth",title=="Riccioli al Cinque Sapori")
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Expression
--R      Integer

--I   Compiling function %LA with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %LC with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %LE with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Riccioli al Cinque Sapori"
--R                                               Type: ThreeDimensionalViewport
--E 474
--S 475 of 676
zoom(v3d,2.0,2.0,2.0)
--R                                                                   Type: Void
--E 475
--S 476 of 676
close(v3d)
--R                                                                   Type: Void
--E 476

———-

68 Rigatoni

Members of the pasta corta (short pasta) branch, and originally from southern Italy, rigatoni (large ridges) are very versitile. Their robust shape holds cream or tomato sauces well, but rigatoni are best eaten with sausages or game meat, mushrooms, and black pepper.

— * —

)clear all
--S 477 of 676
X(i,j) == 0.2*sin((7*i+15)*%pi/30)+2*cos((j+60)*%pi/120) + _
          (7+(60-j)/60.0*sin(i*%pi/240))*cos(i*%pi/120)
--R                                                                   Type: Void
--E 477
--S 478 of 676
Y(i,j) == 0.2*sin(7*i*%pi/30)+(8+0.1*(60-j)/60+j/30*cos(i*%pi/240)) * _
          sin(i*%pi/120)
--R                                                                   Type: Void
--E 478
--S 479 of 676
Z(i,j) == j/2.0
--R                                                                   Type: Void

--E 479
--S 480 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..240,j=0..60,_
           style=="smooth",title=="Rigatoni")
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Polynomial
--R      Float
--I   Compiling function %LG with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %LI with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %LK with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Rigatoni"
--R                                               Type: ThreeDimensionalViewport
--E 480
--S 481 of 676
close(v3d)
--R                                                                   Type: Void
--E 481

———-

69 Rombi

A lesser-known pasta corta, rombi (rhombuses) feature two curled edges like lasagna doppia riccia, however, they are smaller and sheared on the diagonal. Generally served with sauce and pastasciutta or in brodo (in broth), according to size.

— * —

)clear all
--S 482 of 676
X(i,j) == _
  if ((13 <= i) and (i <= 37)) _
    then i/20.0+j/25.0-1/20.0 _
    else if (i <= 13) _
          then 3.0*i/65.0+j/25.0 _
          else 6/65.0+3.0*i/65.0+j/25.0
--R                                                                   Type: Void
--E 482

--S 483 of 676
Y(i,j) == j/25.0
--R                                                                   Type: Void
--E 483
--S 484 of 676
Z(i,j) == _
  if ((13 <= i) and (i <= 37)) _
   then 0.0 _
   else if (i <= 13) _
         then 0.2*((13.0-i)/13.0)*cos((2.0*j+12.5)*%pi/25) _
         else (i-37.0)/65.0*cos((2.0*j+37.5)*%pi/25)
--R                                                                   Type: Void
--E 484
--S 485 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..50,j=0..50,_
           style=="smooth",title=="Rombi")
--R   Compiling function X with type (Variable i,Variable j) -> Polynomial
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Polynomial
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Expression
--R      Float
--I   Compiling function %LM with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %LO with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %LQ with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Rombi"
--R                                               Type: ThreeDimensionalViewport
--E 485
--S 486 of 676
zoom(v3d,2.0,2.0,2.0)
--R                                                                   Type: Void
--E 486
--S 487 of 676
close(v3d)
--R                                                                   Type: Void
--E 487

———-

70 Rotelle

A modern design from the more unusual side of the pasta corta (short pasta) family, rotelle (small wheels) are constructed with spokes that help trap various flavors, making the pasta a good companion for a variety of sauces. Smaller versions can be served in salads or cooked in soups.

— * —

)clear all
--S 488 of 676
X0(i,j) == 0.5*cos(i*%pi/1000)+1.5*(abs(sin(3*i*%pi/1000)))^50*cos(i*%pi/1000)
--R                                                                   Type: Void
--E 488
--S 489 of 676
Y0(i,j) == 0.5*sin(i*%pi/1000)+1.5*(abs(sin(3*i*%pi/1000)))^50*sin(i*%pi/1000)
--R                                                                   Type: Void
--E 489
--S 490 of 676
X1(i,j) == _
  if (i <= 666) _
   then 2*cos(3*i*%pi/1000)+0.03*cos(93*i*%pi/1000) _
   else 2.03
--R                                                                   Type: Void
--E 490
--S 491 of 676
Y1(i,j) == _
  if (i <= 666) _
   then 2.05*sin(3*i*%pi/1000)+0.03*sin(93*i*%pi/1000) _
   else 0.0
--R                                                                   Type: Void
--E 491
--S 492 of 676
Z(i,j) == j/5.0
--R                                                                   Type: Void
--E 492
--S 493 of 676
vsp:=createThreeSpace()
--R
--R   (6)  3-Space with 0 components
--R                                                 Type: ThreeSpace DoubleFloat
--E 493
--S 494 of 676
makeObject(surface(X0(i,j),Y0(i,j),Z(i,j)),i=0..2000,j=0..5,space==vsp)

--R   Compiling function X0 with type (Variable i,Variable j) ->
--R      Expression Float
--R   Compiling function Y0 with type (Variable i,Variable j) ->
--R      Expression Float
--R   Compiling function Z with type (Variable i,Variable j) -> Polynomial
--R      Float
--I   Compiling function %LR with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %LS with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %LU with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R
--R   (7)  3-Space with 1 component
--R                                                 Type: ThreeSpace DoubleFloat
--E 494
--S 495 of 676
makeObject(surface(X0(i,j),Y0(i,j),Z(i,j)),i=0..2000,j=0..5,space==vsp)
--I   Compiling function %LV with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %LW with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %LY with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R
--R   (8)  3-Space with 2 components
--R                                                 Type: ThreeSpace DoubleFloat
--E 495
--S 496 of 676
vp:=makeViewport3D(vsp,style=="smooth",title=="Rotelle")
--R   Transmitting data...
--R
--R   (9)  ThreeDimensionalViewport: "Rotelle"
--R                                               Type: ThreeDimensionalViewport
--E 496
--S 497 of 676
close(vp)
--R                                                                   Type: Void
--E 497

———-

71 Saccottini

Another out-and-out member of the pasta ripiena (filled pasta) club, saccottini-like fagottini, to which they are closely related - are made of a durum-wheat circle of dough gathered into an irregular ball-shaped bundle. Saccottini are usually stuffed with ricotta, meat, or steamed greens.

— * —

)clear all
--S 498 of 676
X(i,j) == cos(i*%pi/75)*(sin(j*%pi/50)+1.3*sin(j*%pi/200) + _
          3*j/1000.0*cos((i+25)*%pi/25))
--R                                                                   Type: Void
--E 498
--S 499 of 676
Y(i,j) == sin(i*%pi/75)*(sin(j*%pi/50)+1.3*sin(j*%pi/200) + _
          0.7*(j/100.0)^2*sin(i*%pi/15))
--R                                                                   Type: Void
--E 499
--S 500 of 676
Z(i,j) == 2*(1-(abs(cos(j*%pi/200)))^5+(j/100.0)^4.5)
--R                                                                   Type: Void
--E 500
--S 501 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..150,j=0..100,_
           style=="smooth",title=="Saccottini")
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Expression
--R      Float
--I   Compiling function %MA with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %MC with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %MD with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Saccottini"
--R                                               Type: ThreeDimensionalViewport
--E 501
--S 502 of 676
close(v3d)

———-

72 Sagnarelli

This short and rectangular ribbon with four indented edges belongs to the pasta lunga (long pasta) branch. Sagnarelli are sometimes made with eggs and are generally served as pastasciutta with a meat ragu, or alongside vegetables such as wild asparagus.

— * —

)clear all
--S 503 of 676
A(i) == 0.5*sin((i+1.5)*%pi/3)
--R                                                                   Type: Void
--E 503
--S 504 of 676
B(i) == 0.05*sin((9*i+12.5)*%pi/25)
--R                                                                   Type: Void
--E 504
--S 505 of 676
X(i,j) == i/10.0+A(j)*(cos(i*%pi/120)^100-sin(i*%pi/200)^100)
--R                                                                   Type: Void
--E 505
--S 506 of 676
Y(i,j) == j/20.0+B(i)*(cos(j*%pi/120)^100-sin(j*%pi/200)^100)
--R                                                                   Type: Void
--E 506
--S 507 of 676
Z(i,j) == 0.0
--R                                                                   Type: Void
--E 507
--S 508 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..100,j=0..60,_
           style=="smooth",title=="Sagnarelli")
--R   Compiling function A with type Variable j -> Expression Float
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function B with type Variable i -> Expression Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float

--R   Compiling function Z with type (Variable i,Variable j) -> Float
--I   Compiling function %MF with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %MH with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %MJ with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (6)  ThreeDimensionalViewport: "Sagnarelli"
--R                                               Type: ThreeDimensionalViewport
--E 508
--S 509 of 676
close(v3d)
--R                                                                   Type: Void
--E 509

———-

73 Sagne Incannulate

Shaping the twisted ribbons of durum-wheat pasta known as sagne incannulate requires skill. Strips of dough are held at the end against a wooden board with one hand, while the palm of the other rolls the rest of the pasta lunga (long pasta) to form the distinctive curl. Sagne are best consumed with a thick sauce or a traditional ragu.

— * —

)clear all
--S 510 of 676
X0(i,j) == (1-0.2*sin(3*j*%pi/20))*cos((i+10)*%pi/20) + _
           2*sin((i-100)*%pi/200)+(3*i)/200.0*sin(i*%pi/400)^200
--R                                                                   Type: Void
--E 510
--S 511 of 676
Y0(i,j) == (1-0.2*sin(3*j*%pi/20))*sin((i+10)*%pi/20)+sin((i-50)/200*%pi)
--R                                                                   Type: Void
--E 511
--S 512 of 676
X1(i,j) == -3+(1-0.1*sin(3*j*%pi/20))*sin((3*i-10)*%pi/50) + _
           cos(i*%pi/200)+3*i/200.0*sin(i*%pi/400)^5
--R                                                                   Type: Void
--E 512
--S 513 of 676

Y1(i,j) == -5+(1-01.*sin(3*j*%pi/20))*cos((3*i+10)*%pi/50)+2*sin(i*%pi/200)
--R                                                                   Type: Void
--E 513
--S 514 of 676
Z(i,j) == i/4.0+7/2.0*(1+cos(j*%pi/20))
--R                                                                   Type: Void
--E 514
--S 515 of 676
vsp:=createThreeSpace()
--R
--R   (6)  3-Space with 0 components
--R                                                 Type: ThreeSpace DoubleFloat
--E 515
--S 516 of 676
makeObject(surface(X0(i,j),Y0(i,j),Z(i,j)),i=0..200,j=0..20,space==vsp)
--R   Compiling function X0 with type (Variable i,Variable j) ->
--R      Expression Float
--R   Compiling function Y0 with type (Variable i,Variable j) ->
--R      Expression Float
--R   Compiling function Z with type (Variable i,Variable j) -> Expression
--R      Float
--I   Compiling function %ML with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %MN with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %MP with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R
--R   (7)  3-Space with 1 component
--R                                                 Type: ThreeSpace DoubleFloat
--E 516
--S 517 of 676
makeObject(surface(X1(i,j),Y1(i,j),Z(i,j)),i=0..200,j=0..20,space==vsp)
--R   Compiling function X1 with type (Variable i,Variable j) ->
--R      Expression Float
--R   Compiling function Y1 with type (Variable i,Variable j) ->
--R      Expression Float
--I   Compiling function %MR with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %MT with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %MV with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R
--R   (8)  3-Space with 2 components
--R                                                 Type: ThreeSpace DoubleFloat

--E 517
--S 518 of 676
vp:=makeViewport3D(vsp,style=="smooth",title=="Sagne Incannulate")
--R   Transmitting data...
--R
--R   (9)  ThreeDimensionalViewport: "Sagne Incannulate"
--R                                               Type: ThreeDimensionalViewport
--E 518
--S 519 of 676
zoom(vp,3.0,3.0,3.0)
--R                                                                   Type: Void
--E 519
--S 520 of 676
close(vp)
--R                                                                   Type: Void
--E 520

———-

74 Scialatielli

Hailing from the Amalfi coast in the province of Naples, scialatielli are a rustic pasta lunga (long pasta) similar in appearance to fettuccine and tagliotelle. When they are made, milk and eggs can be added to the durum-wheat flour to lend it a golden color, Scialatielli are best paired with seafood, or a ragu of pork or veal.

— * —

)clear all
--S 521 of 676
X(i,j) == 0.1*cos(i*%pi/75)+0.1*cos((i+7.5)*%pi/75)^3+0.1*sin(j*%pi/50)
--R                                                                   Type: Void
--E 521
--S 522 of 676
Y(i,j) == 0.1*cos(i*%pi/75)+0.2*sin(i*%pi/75)^3+0.1*sin(j*%pi/50)
--R                                                                   Type: Void
--E 522
--S 523 of 676
Z(i,j) == 3.0*j/50.0
--R                                                                   Type: Void
--E 523
--S 524 of 676

v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..150,j=0..50,_
           style=="smooth",title=="Scialatielli")
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Polynomial
--R      Float
--I   Compiling function %MX with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %MZ with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %NB with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Scialatielli"
--R                                               Type: ThreeDimensionalViewport
--E 524
--S 525 of 676
zoom(v3d,2.0,2.0,2.0)
--R                                                                   Type: Void
--E 525
--S 526 of 676
close(v3d)
--R                                                                   Type: Void
--E 526

———-

75 Spaccatelle

This noted speciality of Sicily belongs to the pasta corta (short pasta) family. Spaccatelle are generally elongated curves with a concave centre, and are served as a pastasciutta (pasta boiled and drained) with a light tomato sauce or a thick meaty ragu.

— * —

)clear all
--S 527 of 676
X(i,j) == (0.5+5*(j/100.0)^3+0.5*cos((i+37.5)*%pi/25))*cos(2*j*%pi/125)
--R                                                                   Type: Void
--E 527
--S 528 of 676
Y(i,j) == 0.6*sin((i+37.5)*%pi/25)

--S 529 of 676
Z(i,j) == (0.5+5*(j/100.0)^3+0.5*cos((i+37.5)*%pi/25))*sin(2*j*%pi/125)
--R                                                                   Type: Void
--E 529
--S 530 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..25,j=0..100,_
           style=="smooth",title=="Spaccatelle")
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Expression
--R      Float
--I   Compiling function %ND with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %NF with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %NH with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Spaccatelle"
--R                                               Type: ThreeDimensionalViewport
--E 530
--S 531 of 676
zoom(v3d,2.0,2.0,2.0)
--R                                                                   Type: Void
--E 531
--S 532 of 676
close(v3d)
--R                                                                   Type: Void
--E 532

———-

76 Spaghetti

Without a doubt, spaghetti (small strings) remain the best-known and most versatile pasta lunga (long pasta) worldwide. Above all they are known for accompanying ragu bolognese, a mixture containing beef, tomato, cream, onions, and pancetta. More recently, spaghetti have become popular in a creamy carbonara.

— * —

--S 533 of 676
X(i,j) == 0.1*cos(i*%pi/20)
--R                                                                   Type: Void
--E 533
--S 534 of 676
Y(i,j) == 0.1*sin(i*%pi/20)
--R                                                                   Type: Void
--E 534
--S 535 of 676
Z(i,j) == j/10.0
--R                                                                   Type: Void
--E 535
--S 536 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..40,j=0..100,_
           style=="smooth",title=="Spaghetti")
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Polynomial
--R      Float
--I   Compiling function %NJ with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %NL with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %NN with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Spaghetti"
--R                                               Type: ThreeDimensionalViewport
--E 536
--S 537 of 676
zoom(v3d,3.0,3.0,3.0)
--R                                                                   Type: Void
--E 537
--S 538 of 676
close(v3d)
--R                                                                   Type: Void
--E 538

———-

77 Spiralli

The ridged and helicoidal spirali (spirals) are similar in shape to cavatappi, but are slightly larger. Spirali may be served with chunky sauces as pastasciutta, baked al forno (at the oven) with a thick cheese topping or added to salads.

— * —

)clear all
--S 539 of 676
X(i,j) == (2.5+2*cos(i*%pi/50)+0.1*cos(i*%pi/5))*cos(j*%pi/30)
--R                                                                   Type: Void
--E 539
--S 540 of 676
Y(i,j) == (2.5+2*cos(i*%pi/50)+0.1*cos(i*%pi/5))*sin(j*%pi/30)
--R                                                                   Type: Void
--E 540
--S 541 of 676
Z(i,j) == (2.5+2*sin(i*%pi/50)+0.1*sin(i*%pi/5))+j/6.0
--R                                                                   Type: Void
--E 541
--S 542 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..100,j=0..120,_
           style=="smooth",title=="Spiralli")
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Expression
--R      Float
--I   Compiling function %NP with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %NR with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %NT with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Spiralli"
--R                                               Type: ThreeDimensionalViewport
--E 542
--S 543 of 676
zoom(v3d,2.5,2.5,2.5)
--R                                                                   Type: Void
--E 543

--S 544 of 676
close(v3d)
--R                                                                   Type: Void
--E 544

———-

78 Stellette

A member of the pastine minute (tiny pasta) family, stellette (little stars) are only marginally larger than both acini di pepe and cuoretti. Like all pastine, they are best served in a light soup, perhaps flavored with portobello mushrooms or peas.

— * —

)clear all
--S 545 of 676
X(i,j) == (3.0+3.0*i/5.0)*cos(j*%pi/75)+i/10*cos((j+15)*%pi/15)
--R                                                                   Type: Void
--E 545
--S 546 of 676
Y(i,j) == (3.0+3.0*i/5.0)*sin(j*%pi/75)+i/10*sin(j*%pi/15)
--R                                                                   Type: Void
--E 546
--S 547 of 676
Z(i,j) == 0.0
--R                                                                   Type: Void
--E 547
--S 548 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..25,j=0..150,_
           style=="smooth",title=="Stellette")
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Float
--I   Compiling function %NV with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %NX with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %NZ with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Stellette"

--S 549 of 676
close(v3d)
--R                                                                   Type: Void
--E 549

———-

79 Stortini

Another pastine minute (tiny pasta), stortini (little crooked pieces) are consumed in creamy soups with mushroom and celery. As a rule of thumb, smaller pasta is best in thinner soups, while larger pastina minute can be served with thicker varieties.

— * —

)clear all
--S 550 of 676
A(i,j) == 0.5*(abs(sin(2*i*%pi/125)))^3
--R                                                                   Type: Void
--E 550
--S 551 of 676
B(i,j) == 1-abs(sin((2*i-500)*%pi/125))
--R                                                                   Type: Void
--E 551
--S 552 of 676
C(i,j) == 1-0.5*(abs(sin(2*(i-375)*%pi/125)))^3
--R                                                                   Type: Void
--E 552
--S 553 of 676
X(i,j) == _
  if (i <= 250) _
   then cos(2*i*%pi/125) _
   else 1.7-cos((2*i-500)*%pi/125)
--R                                                                   Type: Void
--E 553
--S 554 of 676
Y(i,j) == _
  if (i <= 250) _
   then if (i <= 125) _
         then abs(sin(2*i*%pi/125)) _
         else A(i,j) _

   else if (i <= 375) _
         then B(i,j) _
         else C(i,j)
--R                                                                   Type: Void
--E 554
--S 555 of 676
Z(i,j) == j/20.0
--R                                                                   Type: Void
--E 555
--S 556 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..500,j=0..10,_
           style=="smooth",title=="Stortini")
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function A with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function B with type (Variable i,Variable j) -> Expression
--R      Integer
--R   Compiling function C with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Polynomial
--R      Float
--I   Compiling function %OB with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %OC with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %OE with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (7)  ThreeDimensionalViewport: "Stortini"
--R                                               Type: ThreeDimensionalViewport
--E 556
--S 557 of 676
zoom(v3d,3.0,3.0,3.0)
--R                                                                   Type: Void
--E 557
--S 558 of 676
close(v3d)
--R                                                                   Type: Void
--E 558

———-

80 Strozzapreti

The dough used to make strozzapreti (or strangolapreti; both translate to ’priest stranglers’) can be prepared with assorted flours, eggs, and even potato. Strozzapreti are an ideal pastasciutta, and can be served with a traditional meat sauce, topped with Parmigiano-Reggiano.

— * —

)clear all
--S 559 of 676
A(i,j) == 0.5*cos(j*%pi/40)+0.5*cos((j+76)*%pi/40) + _
          0.5*cos(j*%pi/30)+0.5*sin((2*i-j)*%pi/40)
--R                                                                   Type: Void
--E 559
--S 560 of 676
B(i,j) == 0.5*sin(j*%pi/40)+0.5*sin((j+76)*%pi/40) + _
          0.5*sin(j*%pi/30)+0.5*cos((2*i-j)*%pi/40)
--R                                                                   Type: Void
--E 560
--S 561 of 676
X(i,j) == _
  if (i <= 30) _
   then 0.5*cos(j*%pi/30)+0.5*cos((2*i+j+16)*%pi/40) _
   else A(i,j)
--R                                                                   Type: Void
--E 561
--S 562 of 676
Y(i,j) == _
  if (i <= 30) _
   then 0.5*sin(j*%pi/30)+0.5*sin((2*i+j+16)*%pi/40) _
   else B(i,j)
--R                                                                   Type: Void
--E 562
--S 563 of 676
Z(i,j) == j/4.0
--R                                                                   Type: Void
--E 563
--S 564 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..60,j=0..60,_
           style=="smooth",title=="Strozzapreti")
--R   Compiling function A with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float

--R   Compiling function B with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Polynomial
--R      Float
--I   Compiling function %OG with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %OI with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %OK with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (6)  ThreeDimensionalViewport: "Strozzapreti"
--R                                               Type: ThreeDimensionalViewport
--E 564
--S 565 of 676
zoom(v3d,2.5,2.5,2.5)
--R                                                                   Type: Void
--E 565
--S 566 of 676
close(v3d)
--R                                                                   Type: Void
--E 566

———-

81 Tagliatelle

A mixture of wheat-flour and eggs, tagliatelle (derived from the Italian tagliare - ’to cut’) belong to the pasta lunga (long pasta) family. Originally hailing from the north of Italy, tagliatelle are frequently served in carbonara sauce, but can also accompany seafood, or alternatively may form the basis of a timballo (baked pasta dish).

— * —

)clear all
--S 567 of 676
X0(i,j) == 0.4*cos(3*i*%pi/250)+j/80.0*sin(31*i*%pi/1000)
--R                                                                   Type: Void
--E 567
--S 568 of 676
Y0(i,j) == 0.4*sin(3*i*%pi/250)*sin(i*%pi/4000)^0.1
--R                                                                   Type: Void

--E 568
--S 569 of 676
Z0(i,j) == j/80.0+0.12*sin(9*i*%pi/1000)
--R                                                                   Type: Void
--E 569
--S 570 of 676
X1(i,j) == 0.4*cos(3*i*%pi/250)+j/80.0*sin(31*i*%pi/1000)
--R                                                                   Type: Void
--E 570
--S 571 of 676
Y1(i,j) == 0.4*sin(i*%pi/4000)^0.5*sin(3*i*%pi/250)
--R                                                                   Type: Void
--E 571
--S 572 of 676
Z1(i,j) == j/80.0+0.12*sin(9*i*%pi/1000)
--R                                                                   Type: Void
--E 572
--S 573 of 676
vsp:=createThreeSpace()
--R
--R   (7)  3-Space with 0 components
--R                                                 Type: ThreeSpace DoubleFloat
--E 573
--S 574 of 676
makeObject(surface(X0(i,j),Y0(i,j),Z0(i,j)),i=0..1000,j=0..4,space==vsp)
--R   Compiling function X0 with type (Variable i,Variable j) ->
--R      Expression Float
--R   Compiling function Y0 with type (Variable i,Variable j) ->
--R      Expression Float
--R   Compiling function Z0 with type (Variable i,Variable j) ->
--R      Expression Float
--I   Compiling function %OM with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %OO with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %OQ with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R
--R   (8)  3-Space with 1 component
--R                                                 Type: ThreeSpace DoubleFloat
--E 574
--S 575 of 676
makeObject(surface(0.8*X1(i,j),Y1(i,j),0.9*Z1(i,j)),i=0..1000,j=0..4,_

           space==vsp)
--R   Compiling function X1 with type (Variable i,Variable j) ->
--R      Expression Float
--R   Compiling function Y1 with type (Variable i,Variable j) ->
--R      Expression Float
--R   Compiling function Z1 with type (Variable i,Variable j) ->
--R      Expression Float
--I   Compiling function %OS with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %OU with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %OW with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R
--R   (9)  3-Space with 2 components
--R                                                 Type: ThreeSpace DoubleFloat
--E 575
--S 576 of 676
makeObject(surface(X1(i,j),0.9*Y1(i,j),0.6*Z1(i,j)),i=0..1000,j=0..4,_
           space==vsp)
--I   Compiling function %OY with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %PA with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %PC with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R
--R   (10)  3-Space with 3 components
--R                                                 Type: ThreeSpace DoubleFloat
--E 576
--S 577 of 676
vp:=makeViewport3D(vsp,style=="smooth",title=="Tagliatelle")
--R   Transmitting data...
--R
--R   (11)  ThreeDimensionalViewport: "Tagliatelle"
--R                                               Type: ThreeDimensionalViewport
--E 577
--S 578 of 676
close(vp)
--R                                                                   Type: Void
--E 578

———-

82 Taglierini

Another coiling pasta lunga (long pasta), taglierini are of the same lineage as tagliatelle, but are substantially narrower - almost hair-like.

— * —

)clear all
--S 579 of 676
X0(i,j) == 0.5*cos(i*%pi/100)+0.05*cos(i*%pi/40)
--R                                                                   Type: Void
--E 579
--S 580 of 676
Y0(i,j) == 0.5*sin(i*%pi/4000)^0.1*sin(i*%pi/100)+0.075*sin(i*%pi/40)
--R                                                                   Type: Void
--E 580
--S 581 of 676
Z0(i,j) == 3.0*j/200.0+0.1*sin(i*%pi/125)
--R                                                                   Type: Void
--E 581
--S 582 of 676
X1(i,j) == 0.4*cos(i*%pi/100)
--R                                                                   Type: Void
--E 582
--S 583 of 676
Y1(i,j) == 0.4*sin(i*%pi/4000)^0.2*sin(i*%pi/100)
--R                                                                   Type: Void
--E 583
--S 584 of 676
Z1(i,j) == 3.0*j/200.0+0.1*sin(i*%pi/125)
--R                                                                   Type: Void
--E 584
--S 585 of 676
X2(i,j) == 0.3*cos(i*%pi/100)
--R                                                                   Type: Void
--E 585
--S 586 of 676
Y2(i,j) == 0.3*sin(3*i*%pi/1000)*sin(i*%pi/50)
--R                                                                   Type: Void
--E 586
--S 587 of 676
Z2(i,j) == -0.05+3.0*j/200.0+0.1*sin(i*%pi/125)

--S 588 of 676
vsp:=createThreeSpace()
--R
--R   (10)  3-Space with 0 components
--R                                                 Type: ThreeSpace DoubleFloat
--E 588
--S 589 of 676
makeObject(surface(X0(i,j)*0.6,Y0(i,j)*0.5,Z0(i,j)),i=0..1000,j=0..2,_
           space==vsp)
--R   Compiling function X0 with type (Variable i,Variable j) ->
--R      Expression Float
--R   Compiling function Y0 with type (Variable i,Variable j) ->
--R      Expression Float
--R   Compiling function Z0 with type (Variable i,Variable j) ->
--R      Expression Float
--I   Compiling function %PE with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %PG with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %PI with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R
--R   (11)  3-Space with 1 component
--R                                                 Type: ThreeSpace DoubleFloat
--E 589
--S 590 of 676
makeObject(surface(X1(i,j),Y1(i,j),Z1(i,j)),i=0..1000,j=0..2,space==vsp)
--R   Compiling function X1 with type (Variable i,Variable j) ->
--R      Expression Float
--R   Compiling function Y1 with type (Variable i,Variable j) ->
--R      Expression Float
--R   Compiling function Z1 with type (Variable i,Variable j) ->
--R      Expression Float
--I   Compiling function %PK with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %PM with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %PO with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R
--R   (12)  3-Space with 2 components
--R                                                 Type: ThreeSpace DoubleFloat
--E 590
--S 591 of 676

makeObject(surface(0.8*X1(i,j),0.9*Y1(i,j),1.3*Z1(i,j)),i=0..1000,j=0..2,_
           space==vsp)
--I   Compiling function %PQ with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %PS with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %PU with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R
--R   (13)  3-Space with 3 components
--R                                                 Type: ThreeSpace DoubleFloat
--E 591
--S 592 of 676
makeObject(surface(X2(i,j),0.9*Y2(i,j),1.5*Z2(i,j)),i=0..1000,j=0..2,_
           space==vsp)
--R   Compiling function X2 with type (Variable i,Variable j) ->
--R      Expression Float
--R   Compiling function Y2 with type (Variable i,Variable j) ->
--R      Expression Float
--R   Compiling function Z2 with type (Variable i,Variable j) ->
--R      Expression Float
--I   Compiling function %PW with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %PY with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %QA with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R
--R   (14)  3-Space with 4 components
--R                                                 Type: ThreeSpace DoubleFloat
--E 592
--S 593 of 676
vp:=makeViewport3D(vsp,style=="smooth",title=="Taglierini")
--R   Transmitting data...
--R
--R   (15)  ThreeDimensionalViewport: "Taglierini"
--R                                               Type: ThreeDimensionalViewport
--E 593
--S 594 of 676
close(vp)
--R                                                                   Type: Void
--E 594

———-

83 Tagliolini

Thinner even than taglierini, tagliolini are traditionally eaten as a starter with butter, soft cheese, or al pomodoro (in a light tomato sauce). Alternatively, they may be served in a chicken broth. A versatile pasta, tagliolini are also the main ingredient for a variety of timballo dishes baked al forno (at the oven).

— * —

)clear all
--S 595 of 676
X0(i,j) == 0.5*cos(i*%pi/200)+0.05*cos(5*i*%pi/400)
--R                                                                   Type: Void
--E 595
--S 596 of 676
Y0(i,j) == 0.5*sin(i*%pi/8000)^0.1*sin(i*%pi/200)+0.075*sin(5*i*%pi/400)
--R                                                                   Type: Void
--E 596
--S 597 of 676
Z0(i,j) == 0.01*j+0.1*sin(i*%pi/250)
--R                                                                   Type: Void
--E 597
--S 598 of 676
X1(i,j) == 0.4*cos(i*%pi/200)
--R                                                                   Type: Void
--E 598
--S 599 of 676
Y1(i,j) == 0.4*sin(i*%pi/8000)^0.2*sin(i*%pi/200)
--R                                                                   Type: Void
--E 599
--S 600 of 676
Z1(i,j) == 0.01*j+0.1*sin(i*%pi/250)
--R                                                                   Type: Void
--E 600
--S 601 of 676
X2(i,j) == 0.3*cos(i*%pi/125)
--R                                                                   Type: Void
--E 601
--S 602 of 676
Y2(i,j) == 0.3*sin(3*i*%pi/2000)*sin(3*i*%pi/200)
--R                                                                   Type: Void
--E 602

--S 603 of 676
Z2(i,j) == -0.05+0.01*j+0.1*sin(i*%pi/250)
--R                                                                   Type: Void
--E 603
--S 604 of 676
vsp:=createThreeSpace()
--R
--R   (10)  3-Space with 0 components
--R                                                 Type: ThreeSpace DoubleFloat
--E 604
--S 605 of 676
makeObject(surface(X0(i,j)*0.6,Y0(i,j)*0.5,Z0(i,j)),i=0..2000,j=0..1,_
           space==vsp)
--R   Compiling function X0 with type (Variable i,Variable j) ->
--R      Expression Float
--R   Compiling function Y0 with type (Variable i,Variable j) ->
--R      Expression Float
--R   Compiling function Z0 with type (Variable i,Variable j) ->
--R      Expression Float
--I   Compiling function %QC with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %QE with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %QG with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R
--R   (11)  3-Space with 1 component
--R                                                 Type: ThreeSpace DoubleFloat
--E 605
--S 606 of 676
makeObject(surface(X1(i,j),Y1(i,j),Z1(i,j)),i=0..2000,j=0..2,space==vsp)
--R   Compiling function X1 with type (Variable i,Variable j) ->
--R      Expression Float
--R   Compiling function Y1 with type (Variable i,Variable j) ->
--R      Expression Float
--R   Compiling function Z1 with type (Variable i,Variable j) ->
--R      Expression Float
--I   Compiling function %QI with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %QK with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %QM with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R
--R   (12)  3-Space with 2 components
--R                                                 Type: ThreeSpace DoubleFloat
--E 606

--S 607 of 676
makeObject(surface(0.8*X1(i,j),0.9*Y1(i,j),1.3*Z1(i,j)),i=0..2000,j=0..2,_
           space==vsp)
--I   Compiling function %QO with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %QQ with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %QS with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R
--R   (13)  3-Space with 3 components
--R                                                 Type: ThreeSpace DoubleFloat
--E 607
--S 608 of 676
makeObject(surface(X2(i,j),0.9*Y2(i,j),1.5*Z2(i,j)),i=0..2000,j=0..2,_
           space==vsp)
--R   Compiling function X2 with type (Variable i,Variable j) ->
--R      Expression Float
--R   Compiling function Y2 with type (Variable i,Variable j) ->
--R      Expression Float
--R   Compiling function Z2 with type (Variable i,Variable j) ->
--R      Expression Float
--I   Compiling function %QU with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %QW with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %QY with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R
--R   (14)  3-Space with 4 components
--R                                                 Type: ThreeSpace DoubleFloat
--E 608
--S 609 of 676
vp:=makeViewport3D(vsp,style=="smooth",title=="Tagliolini")
--R   Transmitting data...
--R
--R   (15)  ThreeDimensionalViewport: "Tagliolini"
--R                                               Type: ThreeDimensionalViewport
--E 609
--S 610 of 676
close(vp)
--R                                                                   Type: Void
--E 610

———-

84 Torchietti

The whorls of torchietti (tiny torches) trap chunky sauces will. Also known as maccheroni al torchio, they are best eaten in a tomato sauce with larger, coarsely chopped vegetables such as carrots, broccoli, and cauliflower.

— * —

)clear all
--S 611 of 676
A(i,j) == (3.0*i-60.0)*j/100.0
--R                                                                   Type: Void
--E 611
--S 612 of 676
B(i,j) == (3.0*i-60.0)*(100.0-j)/100.0
--R                                                                   Type: Void
--E 612
--S 613 of 676
C(i,j) == 3.0*(i-20.0)*(100.0-j)/100.0
--R                                                                   Type: Void
--E 613
--S 614 of 676
D(i,j) == 3.0*(i-20.0)*j/100.0
--R                                                                   Type: Void
--E 614
--S 615 of 676
E(i,j) == _
  if ((j <= 50) or (i <= 20)) _
   then A(i,j) _
   else if ((j >= 50) or (i <= 20)) _
         then B(i,j) _
         else if ((j >= 50) or (i >= 20)) _
               then C(i,j) _
               else D(i,j)
--R                                                                   Type: Void
--E 615
--S 616 of 676
F(i,j) == (3+2.5*sin(E(i,j)*%pi/120)+3*sin(j*%pi/200)^10)
--R                                                                   Type: Void
--E 616
--S 617 of 676
X(i,j) == F(i,j)*cos(E(i,j)*%pi/10)+0.1*cos(j*%pi/2)
--R                                                                   Type: Void
--E 617

--S 618 of 676
Y(i,j) == F(i,j)*sin(E(i,j)*%pi/10)+0.1*sin(j*%pi/2)+3*sin(j*%pi/50)
--R                                                                   Type: Void
--E 618
--S 619 of 676
Z(i,j) == 18.0*j/25.0+2.0*E(i,j)/5.0
--R                                                                   Type: Void
--E 619
--S 620 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..40,j=0..100,_
           style=="smooth",title=="Torchietti")
--R   Compiling function A with type (Variable i,Variable j) -> Polynomial
--R      Float
--R   Compiling function B with type (Variable i,Variable j) -> Polynomial
--R      Float
--R   Compiling function C with type (Variable i,Variable j) -> Polynomial
--R      Float
--R   Compiling function D with type (Variable i,Variable j) -> Polynomial
--R      Float
--R   Compiling function E with type (Variable i,Variable j) -> Polynomial
--R      Float
--R   Compiling function F with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Polynomial
--R      Float
--I   Compiling function %RA with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %RC with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %RE with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (10)  ThreeDimensionalViewport: "Torchietti"
--R                                               Type: ThreeDimensionalViewport
--E 620
--S 621 of 676
zoom(v3d,2.0,2.0,2.0)
--R                                                                   Type: Void
--E 621
--S 622 of 676

close(v3d)
--R                                                                   Type: Void
--E 622

———-

85 Tortellini

To prepare a tortellino, a teaspoon of meat, cheese, or vegetables is wrapped in a layer of dough (made of wheat flour and egg) that is then skilfully rolled and folded. These shapely members of the pasta ripiena (filled pasta) family are traditionally eaten in steaming soups, but are also drained and served with a local sauce as pastasciutta.

— * —

)clear all
--S 623 of 676
A(i,j) == 0.2*sin(i*%pi/200)+j/400.0
--R                                                                   Type: Void
--E 623
--S 624 of 676
B(i,j) == cos(j/60.0*(2.7+0.2*sin(i*%pi/120)^50)*%pi+1.4*%pi)
--R                                                                   Type: Void
--E 624
--S 625 of 676
C(i,j) == sin(j/60.0*(2.7+0.2*sin(i*%pi/120)^50)*%pi+1.4*%pi)
--R                                                                   Type: Void
--E 625
--S 626 of 676
X(i,j) == 0.5^(1+0.5*sin(i*%pi/120))*cos((11*i-60)*%pi/600) * _
          (1.35+(3+sin(i*%pi/120))*A(i,j)*B(i,j))
--R                                                                   Type: Void
--E 626
--S 627 of 676
Y(i,j) == 0.5*sin((11*i-60)*%pi/600) * _
          (1.35+(0.6+sin(i*%pi/120))*A(i,j)*B(i,j))
--R                                                                   Type: Void
--E 627
--S 628 of 676
Z(i,j) == 0.15+i/1200.0+0.5*(0.8*sin(i*%pi/120)+j/400.0)*sin(i*%pi/120)*C(i,j)
--R                                                                   Type: Void
--E 628

--S 629 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..120,j=0..60,_
           style=="smooth",title=="Tortellini")
--R   Compiling function A with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function B with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function C with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Expression
--R      Float
--I   Compiling function %RG with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %RI with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %RK with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (7)  ThreeDimensionalViewport: "Tortellini"
--R                                               Type: ThreeDimensionalViewport
--E 629
--S 630 of 676
close(v3d)
--R                                                                   Type: Void
--E 630

———-

86 Tortiglioni

Another classic pasta corta (short pasta), tortiglioni originate from the Campania region of southern Italy. Tortiglioni (deriving from the Italian torquere - ’to cut’) are often baked in a timballo or boiled, drained and served as a pastasciutta coupled with a strong sauce of tomato, chorizo, and black pepper.

— * —

)clear all
--S 631 of 676
X(i,j) == 6*cos(i*%pi/75)-3.5*cos(j*%pi/100) + _
          0.15*sin((13*i/75.0+j/15.0+1.5)*%pi)
--R                                                                   Type: Void

--E 631
--S 632 of 676
Y(i,j) == 6*sin(i*%pi/75)+0.15*sin((13*i/75.0+j/15.0)*%pi)
--R                                                                   Type: Void
--E 632
--S 633 of 676
Z(i,j) == 11.0*j/10.0
--R                                                                   Type: Void
--E 633
--S 634 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..150,j=0..50,_
           style=="smooth",title=="Tortiglioni")
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Polynomial
--R      Float
--I   Compiling function %RM with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %RO with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %RQ with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Tortiglioni"
--R                                               Type: ThreeDimensionalViewport
--E 634
--S 635 of 676
zoom(v3d,2.0,2.0,2.0)
--R                                                                   Type: Void
--E 635
--S 636 of 676
close(v3d)
--R                                                                   Type: Void
--E 636

———-

87 Trenne

A hollow triangular variety of pasta corta (short pasta), trenne (penne with a triangular crosssection) are extremely sturdy. They are best served with mushrooms, tomato, and spinach - or in any sauce that would normally accompany their close cousins: penne, trennette, and ziti.

— * —

)clear all
--S 637 of 676
X(i,j) == _
  (if (i <= 33) _
    then (3.0*i/10.0) _
    else ((300.0-3*i)/20.0))
--R                                                                   Type: Void
--E 637
--S 638 of 676
Y(i,j) == _
 (if (i <= 33) _
   then (0.0) _
   else (if (i <= 66) _
         then ((9*i-300)/20.0) _
         else ((900-9*i)/20.0)))
--R                                                                   Type: Void
--E 638
--S 639 of 676
Z(i,j) == _
 (if (i <= 33) _
   then (if (i <= 16) _
          then (-9.0*i/50.0+6.0*j/4.0) _
          else (-6.0+9.0*i/50.0+3.0*j/2.0) ) _
   else (if (i <= 66) _
          then (-12.0+7.0*i/20.0+6.0*j/4.0) _
          else (35.0-7.0*i/20.0+6.0*j/4.0)))
--R                                                                   Type: Void
--E 639
--S 640 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..100,j=0..40,_
           style=="smooth",title=="Trenne")
--R   Compiling function X with type (Variable i,Variable j) -> Polynomial
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Polynomial
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Polynomial
--R      Float
--I   Compiling function %RS with type (DoubleFloat,DoubleFloat) ->

--R      DoubleFloat
--I   Compiling function %RU with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %RW with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Trenne"
--R                                               Type: ThreeDimensionalViewport
--E 640
--S 641 of 676
close(v3d)
--R                                                                   Type: Void
--E 641

———-

88 Tripoline

The ribbon-like tripoline are pasta lunga (long pasta) curled along one edge only. This wave gives the tripoline a varying texture after cooking, and helps them to gather extra sauce. Originally from southern Italy, they are often served with tomato and basil, or ragu alla napoletana and a sprinkling of Pecorino Romano.

— * —

)clear all
--S 642 of 676
X(i,j) == i/20.0
--R                                                                   Type: Void
--E 642
--S 643 of 676
Y(i,j) == j/20.0
--R                                                                   Type: Void
--E 643
--S 644 of 676
Z(i,j) == _
  if (i <= 30) _
   then 0.0 _
   else if (i <= 10) _
         then (10.0-i)/50.0*cos((j+2)*%pi/4) _
         else ((i-30.0)/50.0)*cos((j+15)*%pi/10)
--R                                                                   Type: Void
--E 644

--S 645 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..40,j=0..200,_
           style=="smooth",title=="Tripoline")
--R   Compiling function X with type (Variable i,Variable j) -> Polynomial
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Polynomial
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Expression
--R      Float
--I   Compiling function %RY with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %SA with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %SC with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Tripoline"
--R                                               Type: ThreeDimensionalViewport
--E 645
--S 646 of 676
zoom(v3d,2.0,2.0,2.0)
--R                                                                   Type: Void
--E 646
--S 647 of 676
close(v3d)
--R                                                                   Type: Void
--E 647

———-

89 Trofie

The Ligurian version of gnocchi, trofie are made from a mixture of wheat flour, bran, water, and potatoes. Traditionally served boiled with green beans and more potatoes, they may also be paired with a simple mix of pesto genovese, pine nuts, salt, and olive oil.

— * —

)clear all
--S 648 of 676
A(i,j) == (3.0*i)/5.0+10*cos(j*%pi/25)
--R                                                                   Type: Void
--E 648
--S 649 of 676

X(i,j) == (1+sin(i*%pi/150)+2*sin(i*%pi/150)*sin(j*%pi/25)) * _
          sin(13*i*%pi/300)
--R                                                                   Type: Void
--E 649
--S 650 of 676
Y(i,j) == (1+sin(i*%pi/150)+2*sin(i*%pi/150)*sin(j*%pi/25)) * _
          cos(13*i*%pi/300)+5*sin(2*A(i,j)*%pi/125)
--R                                                                   Type: Void
--E 650
--S 651 of 676
Z(i,j) == A(i,j)
--R                                                                   Type: Void
--E 651
--S 652 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..150,j=0..50,_
           style=="smooth",title=="Trofie")
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Integer
--R   Compiling function A with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Expression
--R      Float
--I   Compiling function %SE with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %SG with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %SI with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (5)  ThreeDimensionalViewport: "Trofie"
--R                                               Type: ThreeDimensionalViewport
--E 652
--S 653 of 676
zoom(v3d,3.0,3.0,3.0)
--R                                                                   Type: Void
--E 653
--S 654 of 676
close(v3d)
--R                                                                   Type: Void
--E 654

90 Trottole

A well-formed pasta corta (short pasta) comprised of rings that curl up about a central stalk, trottole are ideal for salads. They are also delicious with pumpkin or courgette, leek, pine nuts, and a few shavings of Parmigiano-Reggiano.

— * —

)clear all
--S 655 of 676
A(i,j) == 0.17-0.15*sin(j*%pi/120)+0.25*((60.0-j)/60.0)^10*sin(j*%pi/30)
--R                                                                   Type: Void
--E 655
--S 656 of 676
B(i,j) == 0.17-0.15*sin(j*%pi/120)+0.25*((60.0-j)/60.0)^10*sin(j*%pi/30)
--R                                                                   Type: Void
--E 656
--S 657 of 676
C(i,j) == 0.25*((60.0-j)/60.0)^5*(1-sin((i-128)*%pi/160))*cos(j*%pi/30)
--R                                                                   Type: Void
--E 657
--S 658 of 676
D(i,j) == (7.0*i)/400.0-48/25+C(i,j)+j/120.0*(1-sin((i-128)*%pi/64))
--R                                                                   Type: Void
--E 658
--S 659 of 676
X(i,j) == _
  if (i >= 128) _
   then (A(i,j)*(1-sin((i-128)*%pi/320)))*cos(7*i*%pi/160) _
   else B(i,j)*cos(7*i*%pi/160)
--R                                                                   Type: Void
--E 659
--S 660 of 676
Y(i,j) == _
  if (i >= 128) _
   then (A(i,j)*(1-sin((i-128)*%pi/160)))*sin(7*i*%pi/160) _
   else B(i,j)*sin(7*i*%pi/160)
--R                                                                   Type: Void
--E 660
--S 661 of 676
Z(i,j) == _

  if (i >= 128) _
   then D(i,j) _
   else i/400.0+j/100.0+0.25*((60.0-j)/60.0)^5*cos(j*%pi/30)
--R                                                                   Type: Void
--E 661
--S 662 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..160,j=0..60,_
           style=="smooth",title=="Trottole")
--R   Compiling function A with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function B with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function C with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function D with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Expression
--R      Float
--I   Compiling function %SK with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %SM with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %SO with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (8)  ThreeDimensionalViewport: "Trottole"
--R                                               Type: ThreeDimensionalViewport
--E 662
--S 663 of 676
zoom(v3d,2.0,2.0,2.0)
--R                                                                   Type: Void
--E 663
--S 664 of 676
close(v3d)
--R                                                                   Type: Void
--E 664

———-

91 Tubetti Rigati

The smallest members of the pasta corta (short pasta) clan, tubetti rigati (grooved tubes) were first created in Campania, southern Italy. When served e fagioli (with beans) they create very filling soups, but can also be served in a light marinara (mariner’s) sauce of tomato, basil, and onions.

— * —

)clear all
--S 665 of 676
X(i,j) == 2*cos(i*%pi/75)+0.03*sin((4*i+7.5)*%pi/15)+0.5*cos(j*%pi/60)
--R                                                                   Type: Void
--E 665
--S 666 of 676
Y(i,j) == 2*sin(i*%pi/75)+0.03*sin(4*i*%pi/15)+0.5*sin(j*%pi/60)
--R                                                                   Type: Void
--E 666
--S 667 of 676
Z(i,j) == j/3.0
--R                                                                   Type: Void
--E 667
--S 668 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..150,j=0..30,_
           style=="smooth",title=="Tubetti Rigati")
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Polynomial
--R      Float
--I   Compiling function %SQ with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %SS with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %SU with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Tubetti Rigati"
--R                                               Type: ThreeDimensionalViewport
--E 668
--S 669 of 676
zoom(v3d,2.0,2.0,2.0)
--R                                                                   Type: Void
--E 669

--S 670 of 676
close(v3d)
--R                                                                   Type: Void
--E 670

———-

92 Ziti

A pasta reserved for banquets and special occasions, ziti (’grooms’ or ’brides’ in Italian dialect) originate from Sicily. Tradition has it that they should be broken by hand before being tossed into boiling water. After draining they can be served in tomato sauces with peppers or courgettes, topped with cheese like Provolone.

— * —

)clear all
--S 671 of 676
X(i,j) == 0.5*cos(i*%pi/35)+0.2*sin(j*%pi/70)
--R                                                                   Type: Void
--E 671
--S 672 of 676
Y(i,j) == 0.5*sin(i*%pi/35)+0.2*sin(j*%pi/70)
--R                                                                   Type: Void
--E 672
--S 673 of 676
Z(i,j) == j/14.0
--R                                                                   Type: Void
--E 673
--S 674 of 676
v3d:=draw(surface(X(i,j),Y(i,j),Z(i,j)),i=0..70,j=0..70,_
           style=="smooth",title=="Ziti")
--R   Compiling function X with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Y with type (Variable i,Variable j) -> Expression
--R      Float
--R   Compiling function Z with type (Variable i,Variable j) -> Polynomial
--R      Float
--I   Compiling function %SW with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %SY with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat
--I   Compiling function %TA with type (DoubleFloat,DoubleFloat) ->
--R      DoubleFloat

--R   Transmitting data...
--R
--R   (4)  ThreeDimensionalViewport: "Ziti"
--R                                               Type: ThreeDimensionalViewport
--E 674
--S 675 of 676
zoom(v3d,2.5,2.5,2.5)
--R                                                                   Type: Void
--E 675
--S 676 of 676
close(v3d)
--R                                                                   Type: Void
--E 676
)spool
)lisp (bye)

———-

References^{[1] nothing}

140