bp with probt

8/10/2019 BP With ProBT

1/64

Bayesian Programming

with ProBT c

and some dice

Juan Manuel Ahuactzin Kamel Mekhnacha

Pierre Bessiere Emmanuel Mazer

July 2012


2/64

2


3/64

Chapter 1

Variables

Program 1:Multiple type variables sets.

1 /*========================================================= ==============2 * Product :

3 * File : multipleTypes.cpp

4 * Author : Juan-Manuel Ahuactzin

5 * Creation : 2002-Oct-30 19:29

6 *

7 *========================================================= ==============

8 * (c) Copyright 2008, Probayes SAS,

9 * all rights reserved

10 *========================================================= ==============

11 *

12 *------------------------- Description ---------------------------------

13 * This file gives an example to define multiple type variables

14 * conjunctions

15 *--------------------------------------------------------- --------------

16 */

17

18 #include

19

20

21 using namespace std;

22

23

24 int main()

25 {

26 //Definig types

27 plIntegerType rank_type(0,10);

28 plIntegerType age_type(0,120);

29 plRealType weight_type(40.0,140.0);

30 plRealType height_type(0.2,2.30, 200);

31

32 //Defining single type variables conjunctions

33 plSymbol rank("rank",rank_type);

34 plSymbol age("age",age_type);

3


4/64

4 CHAPTER 1. VARIABLES

35 plSymbol height("height",height_type);

36 plSymbol weight("weight",weight_type);

37 plArray ancestors_height("anc_height",height_type,1,2);

38

39 //Defining a multiple type variable

40 plVariable physical_info(weight^height^ancestors_height);

41 cout


5/64

5

Program 2:Grouping variables.

1 /*========================================================= ==============

2 * Product :

3 * File : groupingVars.cpp

4 * Author : Juan-Manuel Ahuactzin5 * Creation : 2002-Oct-30 19:29

6 *

7 *========================================================= ==============



10 *========================================================= ==============

11 *

12 *------------------------- Description ---------------------------------

13 * This is a simple example showing how to group a set of

14 * variables. We assume having n sensors giving a lecture of a moving

15 * object. A lectures is composed by an angle, a distance and a

16 * velocity in x and y. A set of Left an right lectures is also

17 * constructed. We assume that odd sensors are left sensors and that

18 * even sensors are right sensors

19 * *-----------------------------------------------------------------------

20 */21

22 #include

23


25

26 int main ()

27 {

28 /**********************************************************************

29 Defining types and variables

30 ***********************************************************************/

31

32 //Defining types

33 plIntegerType angle_lecture(0,360);

34 plRealType distance_lecture(0,100.0,50);

35 plRealType velocity_lecture(-50,50,20);

36

37 const unsigned int n_sensors = 6;

38

39 //Defining a plArrays angle(n_sensors) for angles

40 plArray angle("T",angle_lecture,1,n_sensors);

41

42 //Defining a plArrays distance(n_sensors) for distances

43 plArray distance("D",distance_lecture,1,n_sensors);

44

45 //Defining a plArrays velocity(n_sensors, 2). The "2" corresponds to

46 //the x and y components

47 plArray velocity("V",velocity_lecture,2,n_sensors,2);

48

49 /**********************************************************************

50 Joining variables conjunctions by means of the ^ operator

51 ***********************************************************************/

52

53 unsigned int i;


6/64


7/64

7

Program 3:Variable values loops.

1 /*========================================================= ==============

2 * Product :

3 * File : iterateValues.cpp


6 *

7 *========================================================= ==============



10 *========================================================= ==============

11 *

12 *------------------------- Description ---------------------------------

13 * This program shows how to cover all the values of a conjunction of

14 * discrete variables (i.e. creation of loops). Three examples

15 * consisting in the more typical circumstances are shown.

16 *--------------------------------------------------------- --------------

17 */

18

19

20 #include 21


23

24 int main ()

25 {

26 /**********************************************************************

27 Defining the variable type and symbols

28 ***********************************************************************/

29

30 plIntegerType minuteType(0,59);

31 plIntegerType hourType(0,23);

32

33 plSymbol minute("minute",minuteType);

34 plSymbol hour("hour",hourType);

35

36 plRealType temperature(-20,40,100);

37 plRealType humidity(0.0,1.0,25);

38 plRealType speed(0,70,20);

39

40 plSymbol hi("Hi",temperature);

41 plSymbol lo("Lo",temperature);

42 plSymbol wind_speed("wind_speed",speed);

43 plSymbol wind_humidity("wind_humidity",humidity);

44

45 /**********************************************************************

46 First example: A loop for all the variables in the plValues

47 with the order of iteration given by the order used at the creation

48 of the plValues.

49 ***********************************************************************/

50

51 cout


8/64

8 CHAPTER 1. VARIABLES

54

55 time.reset(); // Reset all values in "time"

56 do

57 cout


9/64

Chapter 2

Distributions

2.1 Unconditional distributions

9


10/64

10 CHAPTER 2. DISTRIBUTIONS

Program 4:Throwing a die.

1 /*======================================================= ================

2 * Product :

3 * File : die.cpp


6 *

7 *=========================================================== ============



10 *=========================================================== ============

11 *

12 *------------------------- Description ---------------------------------

13 * This program simulates throwing a symmetric 6 sides die

14 *----------------------------------------------------------- ------------

15 */

16

17 #include

18


2021 int main()

22 {

23 /**********************************************************************

24 Defining the variable type, a symbol and values.

25 **********************************************************************/

26

27 plIntegerType Points_type(1,6); // Type for Points [1,2,...,6]

28 plSymbol Points("Points",Points_type); // Variable set for Points

29 plValues values(Points); // Values for Points

30

31 /**********************************************************************

32 Definig P(Die) = uniform

33 **********************************************************************/

34

35 plUniform P_Points(Points); // Distribution of the variable space

36

37 /**********************************************************************

38 Displaying the defined data

39 **********************************************************************/

40

41 cerr


11/64

2.2. CONDITIONAL DISTRIBUTIONS 11

54

55 for (i=0;i


12/64

12 CHAPTER 2. DISTRIBUTIONS

31 plSymbol Points("Points",Points_type);// Variable set for Points

32 plSymbol Die("Die",Die_type); // Variable set for the Die

33 plValues values(Points Die); // Values for Points and Die

34

35 /**********************************************************************

36 Definig P(Points | Die)

37 **********************************************************************/

3839 // Distributions of dice 1,3 and 4

40 plProbValue distDie1[6] = {0.3, 0.2, 0.1, 0.1, 0.2, 0.1};



43

44 // The conditional distribution P(Points | Die)

45 plDistributionTable P_PointsKDie(Points,Die);

46

47 P_PointsKDie.push(1,plProbTable(Points,distDie1));

48 P_PointsKDie.push(2,plUniform(Points)); // Die 2 is a symmetric die



51

52 // Printing the created objects

53 cerr


13/64

Chapter 3

Bayesian Networks

13


14/64

14 CHAPTER 3. BAYESIAN NETWORKS

Die

Points

0 1

0.36 0.64

Die P oints

1 2 3 4 5 6

0 0.3 0.2 0.1 0.1 0.2 0.1

1 0.16 0.16 0.16 0.16 0.16 0.16

Figure 3.1: The two dice Bayesian network.

Program 6:Two dice..

1 /*======================================================= ================

2 * Product :

3 * File : twoDice.cpp


5 * Creation : Tue Mar 8 15:12:38 2005

6 *

7 *=========================================================== ============

8 *(c) Copyright 2000-2004, Centre National de la Recherche Scientifique,


10 *=========================================================== ============

11 *

12 *------------------------- Description ---------------------------------

13 *

14 *

15 *----------------------------------------------------------- ------------

16 */

17

18

19 #include

20


22

23 int main() {

24 /***************************************************** *****************

25 VARIABLES SPECIFICATION

26 ************************************************************ **********/

27 plIntegerType Die_type(0,1); // Two dice 0 and 1

28 plIntegerType Points_type(1,6); // Type for Points [1,2,...,6]

29 plSymbol Die("Die",Die_type);


15/64

15

twoDice() =

8>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>:

Description

8>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>:

Specification

8>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>:

Relevant Variables:Die, P oints

Decomposition:

P(Die P oints| ) =P(Die| )P(Points| Die )

Parametric Forms:P(Die| ) = 0 1

0.36 0.64

P(Points|Die ) =

Die P oints

1 2 3 4 5 6

0 0.3 0.2 0.1 0.1 0.2 0.1

1 0.16 0.16 0.16 0.16 0.16 0.16

Identification:All tables provided by the user

Question:P(Die|Points)

Figure 3.2: The two dice Bayesian program.

30 plSymbol Points("Points",Points_type);

31

32 /********************************************************** ************

33 PARAMETRIC FORM SPECIFICATION

34 ********************************************************** ************/

35 // P(Die)

36 plProbValue Die_table[] = {0.36, 0.64};

37 plProbTable P_Die(Die, Die_table);

38

39 // Distributions of dice 0

40 plProbValue distDie0[] = {0.3, 0.2, 0.1, 0.1, 0.2, 0.1};

41

42 // The conditional distribution P(Points | Die)

43 plDistributionTable P_PointsKDie(Points,Die);

44


46 P_PointsKDie.push(1,plUniform(Points)); // Die 1 is a symmetric die

47

48 /********************************************************** ************

49 DECOMPOSITION

50 ********************************************************** ************/

51 // P(Die Points) = P(Die) P(Point | Die)

52 plJointDistribution jd(Die^Points, P_Die*P_PointsKDie);

53 jd.draw_graph("twoDice.fig");

54 /********************************************************** ************

55 PROGRAM QUESTION

56 ********************************************************** ************/

57 plCndDistribution question, compiled_question;

58


16/64


59 jd.ask(question, Die, Points); // Compute P(Die | Points)

60 question.compile(compiled_question);

61 cout


17/64

17

A B

C D

E

P(A| )0 1

0.4 0.6

P(B| )0 1

0.18 0.82

P(C| )0 1

0.75 0.25

P(D|A B )A B D

0 1

0 0 0.6 0.4

0 1 0.3 0.7

1 0 0.1 0.9

1 1 0.5 0.5

P(E|C D )C D E

0 1

0 0 0.59 0.41

0 1 0.25 0.75

1 0 0.8 0.2

1 1 0.35 0.65

Figure 3.3: A simple Bayesian network.


18/64


BN() =

8>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>:

Description

8>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>:

Specification

8>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>:

Relevant Variables:A,B,C,D ,E IB

Decomposition:

P(A B C D E | ) =P(A | )P(B| )P(C| )P(D|A B )P(E|C D )

Parametric Forms:P(A | ) = {0.4, 0.6}P(B| ) = {0.18, 0.82}P(C| ) = {0.75, 0.25}

P(D|A B ) =

8>>>:

0.6, 0.40.3, 0.70.1, 0.90.5, 0.5

9>>=>>;

P(E|C D ) =

8>>>:

0.59, 0.410.25, 0.750.80, 0.200.35, 0.65

9>>=>>;


Question:P(C B|[E=true] [D= false])

Figure 3.4: The Bayesian program specification of Figure 3.3.


19/64

19

Program 7:A simple bayesian network.

1 /*========================================================= ==============

2 * Product :

3 * File : BayesianNetwork.cpp

4 * Author : Juan-Manuel Ahuactzin5 * Creation : 2004-Feb-05 15:51

6 *

7 *========================================================= ==============

8 * (c) Copyright 2000, Centre National de la Recherche Scientifique,


10 *========================================================= ==============

11 *

12 *------------------------- Description ---------------------------------

13 *

14 *

15 *--------------------------------------------------------- --------------

16 */

17

18 #include

19 #include

20 using namespace std;21

22 int main()

23 {

24 /**********************************************************************


26 **********************************************************************/

27 plSymbol A("A",PL_BINARY_TYPE);

28 plSymbol B("B",PL_BINARY_TYPE);

29 plSymbol C("C",PL_BINARY_TYPE);

30 plSymbol D("D",PL_BINARY_TYPE);

31 plSymbol E("E",PL_BINARY_TYPE);

32

33 /**********************************************************************


35 **********************************************************************/

36 // Specification of P(A)

37 plProbValue tableA[] = {0.4, 0.6};

38 plProbTable P_A(A, tableA);

39

40 // Specification of P(B)

41 plProbValue tableB[] = {0.18, 0.82};

42 plProbTable P_B(B, tableB);

43

44 // Specification of P(C)

45 plProbValue tableC[] = {0.75, 0.25};

46 plProbTable P_C(C, tableC);

47

48 // Specification of P(D | A B)

49 plProbValue tableD_knowingA_B[] = {0.6, 0.4, // P(D | [A=f]^[B=f])

50 0.3, 0.7, // P(D | [A=f]^[B=t])

51 0.1, 0.9, // P(D | [A=t]^[B=f])

52 0.5, 0.5}; // P(D | [A=t]^[B=t])

53 plDistributionTable P_D(D,A^B,tableD_knowingA_B);


20/64


54

55 // Specification of P(E | C D)

56 plProbValue tableE_knowingC_D[] = {0.59, 0.41, // P(E | [C=f]^[D=f])

57 0.25, 0.75, // P(E | [C=f]^[D=t])

58 0.8, 0.2, // P(E | [C=t]^[D=f])

59 0.35, 0.65}; // P(E | [C=t]^[D=t])

60 plDistributionTable P_E(E,C^D,tableE_knowingC_D);

6162 /**********************************************************************

63 DECOMPOSITION

64 **********************************************************************/

65 plJointDistribution jd(A B^C D^E, P_A*P_B*P_C*P_D*P_E);

66 jd.draw_graph("bayesian_network.fig");

67 cout


21/64

21

Gray Clouds(GC)

Rain(R)

Sprinkler(S)

Wet Grass(WG)

P(GC| )0 1

0.5 0.5

P(R|GC )GC R

0 1

0 0.8 0.2

1 0.35 0.65

P(S|GC )GC S

0 1

0 0.5 0.5

1 0.9 0.1

P(W G|S R )S R W G

0 1

0 0 1.0 0.0

0 1 0.1 0.91 0 0.1 0.9

1 1 0.01 0.99

Figure 3.5: The water-sprinkler Bayesian network.


22/64


Exercise 6: A complicated situation for Peter.Peter will hold a party at home and he invited his best friends: Mary,

Alice, John, Victor, and Bill. Peter would like to have everyone at the party.However, there are various factors that will influence the party attendance.

1. Mary, Alice, John, and Bill will accept the invitation in function ofdifferent events.

John is rainophobe, if he receives the invitation on a rainyday he will refuse it with a probability of 0.6. If he receives theinvitation on a non rainy day he will accept it with a probability0.9.

Alice will accept a weekend invitation with a probability of 0.8and a weekday invitation with a probability of 0.4.

Bill is a very busy man and will not accept a late invitation witha probability 0.7. He will accept an in time invitation with a

probability of 0.95. Mary best friends are John and Alice. Nevertheless, from Marys

point of view John and Alice are always fighting. Consequently,Mary will accept the invitation with a probability 0.05 if bothJohn and Alice accepted the invitation. She will accept with aprobability of 0.95 if John accepted but Alice didnt. Similarly, ifAlice accepted but John didnt she will accept with a probabilityof 0.85. If neither Alice nor John accepted then she will leavethat to chance by flipping a coin.

2. Victor lives with Peter and does not need to accept or refuse the invi-

tation. However, the day of the party he will stay at home dependingon Alice and Bill response. In fact there is some competition betweenBill and Victor for Alice, consequently if both of them accepted thenVictor would be present. If this is not the case, he will decide betweenstaying at home and going to a pub for watching a football game. Ifnone of them accepted then he will stay at home with a probability of0.7. If Alice accepted but Bill didnt then he will stays at home witha probability of 0.9. If Bill accepted and Alice didnt then he will goto the pub with a probability of 0.6.

3. One thing is to accept or to refuse the invitation and another thing isto attend or not to the party. Except for Victor, everyone can change

his or her mind. Peter will accept the attendance of a friend even


23/64

23

if a he or she gave a negative response. In the past, Mary changedher mind 3% of the time. If Alice accepted an invitation then youcan be sure at 80% that she will be present, if she refused then theprobabilities for attendance and non-attendance are equals.

4. John and Bill have extra constraints.

The day of the party John will not come if it rains and if he didntaccept the invitation. However, in the past, when it was rainingand he accepted the invitation he showed up at the party 70% ofthe time. If the day of the party is not raining and he refused theinvitation then he will show up at the party with a probability of0.4; if he accepted then he will show up with a probability of 0.9.

Bill works at the hospital. Hence, if the day of the party thereis an emergency he will not come. If no emergency is presentand he accepted the invitation he will come with a probability

of 0.95; on the contrary, if he refused, then he will come with aprobability of 0.2.

5. The probability of rain is 0.22.

6. The probability of organizing the party at weekend is 0.28

7. The probability of receiving a late invitation is 0.3.

8. The probability of having an emergency at the hospital is 0.65

For the previous description:

i. Identify the variables of the problem

ii. Write Bayesian program: Description + Question. Where the questionis the probability of presence of each of the Peters friends.

iii. Draw the Bayesian network

iv. Write the expressions for the following questions:

(a) What is the probability that it was raining when John receivedthe invitation knowing that Mary didnt attend the party and

that the party is on Monday?


24/64


(b) What is the probability that all Peters friends attend the partyknowing that it will take place on a sunny Saturday, knowingthat Bill received the invitation in time and no emergency waspresent at the hospital?

(c) What is the probability that Alice, Victor and Bill attend the

party?

(d) Alice answer the phone at Peters house, Hi John. What isthe probability that Mary and Victor attended the party? (Note:No, no, no, John is not calling from a cell phone).

v. Write the ProBT Bayesian program modeling the Peters problem andsolving the previous questions.

Program 8:The addition of two dice.

1 /*======================================================= ================

2 * Product :

3 * File : addTwoDice.cpp


5 * Creation : 2008-Oct-02 17:27

6 *

7 *=========================================================== ============



10 *=========================================================== ============

11 *

12 *------------------------- Description ---------------------------------

13 * This program shows the use of external functions by means of C++

14 * functions The construction of a functional dirac is also shown.

15 * The program gives the possible values of two dice given the sum of

16 * points.

17 *----------------------------------------------------------- ------------

18 */

19

20 #include

21


23

24 void add_dice(plValues &addition, const plValues &die) {

25 addition[0] = die[0]+die[1];

26 }

27

28

29 int main()

30 {

31 /***************************************************** *****************



25/64

25

33 ********************************************************** ************/

34 plIntegerType die_type(1,6); // Type for a die [1,2,...,6]

35 plIntegerType dice_sum(2,12); // Type for the sum [2,3,...,12]

36 plArray dice_set("Die",die_type,1,2); // Variable space for the dice

37 plSymbol points("Addition",dice_sum); // Variable space for the addition

38

39 plValues result(dice_set^points); // Values storing the result of the

40 // dice and the addition41 /********************************************************** ************


43 ********************************************************** ************/

44 // Defining P(Die1 Die2) as an uniform distribution

45 plUniform p_dice(dice_set);

46

47 // Defining P(Addition | Die1 Die2) = 1 if

48 // Addition = add_dice(Die1,Die2) else 0

49 plExternalFunction sum(points,dice_set,add_dice);

50 plFunctionalDirac p_addition(points,dice_set,sum);

51

52 /********************************************************** ************

53 DECOMPOSITION

54 ********************************************************** ************/

55 // Defining P(Die1 Die2 Addition) = P(Die1 Die2) P(Addition | Die1 Die2)

56 plJointDistribution dice_jd(dice_set points,p_dice*p_addition);57

58 /********************************************************** ************

59 PROGRAM QUESTION

60 ********************************************************** ************/

61 plCndDistribution cnd_question;

62 plDistribution question;

63 int v;

64

65 // Get P(Die1 Die2 | Addition )

66 dice_jd.ask(cnd_question,dice_set,points);

67 coutv;

68 result[points] = v;

69

70 // Get P(Die1 Die2 | Addition=v)

71 cnd_question.instantiate(question,result);

72 question.tabulate(cout,false);73

74 return 0;

75 }

Exercise 7: Modify the program addTwoDice.cpp so that it accepts anumber n of dice as input? That is, write a program to compute

P(Points|Die1Die2...Dien).

Exercise 8: For the Peters party model introduce a new variable N

representing the number of persons that attend the Party and compute:


26/64


1. the probability distribution for the number of persons that attend theparty (plot the distribution),

2. the probability that it rained on the invitation day knowing that threepersons attended the party.

Consider that your fellow has a box with m dice; secretly she takesN Mdice and throw them on the table. She lets you know that the sumof all points is s. What is the most probable number Nof dice.

Program 9:How many dice do I have?.

1 /*======================================================= ================

2 * Product :

3 * File : addDice3.cpp


5 * Creation : 2002-Oct-30 19:29

6 *7 *=========================================================== ============



10 *=========================================================== ============

11 *

12 *------------------------- Description ---------------------------------

13 * This program computes the more probable number of dice that where

14 * thrown given that we know the total number of points

15 *----------------------------------------------------------- ------------

16 */

17

18 #include

19


21

22 #define SQRT_DIV35_12 1.7078251

23

24 // User function for computing the mean

25 void f_mean(plValues &mean, const plValues &n) {

26 mean[0] = 7*n[0]/2;

27

28 }

29

30 // User function for computing the standard deviation

31 void f_std(plValues &std, const plValues &n) {

32 std[0] = SQRT_DIV35_12*sqrt(double(n[0]));

33

34 }

35

36 int main()

37 {

38 /***************************************************** *****************



27/64

27

40 ********************************************************** ************/

41 plIntegerType die_number(1,10); // Type for the # of dice [1,2,...,100]

42 plIntegerType dice_sum(1,60); // Type for the sum [2,3,...,n*6]


44 plSymbol number("n",die_number); // Variable space for the # of dice

45

46 plValues result(number^points); // Values storing the # of dice

47 // and the addition48

49 /********************************************************** ************


51 **********************************************************************/

52 // P(number) = uniform(number)

53 plUniform p_number(number);

54

55 // Create the external functions to compute the mean and the

56 // standard deviation

57 plExternalFunction f_mu(number,f_mean);

58 plExternalFunction f_sigma(number,f_std);

59

60 // P(points | number) = CndBellShape(points,f_mu(number),f_sigma(number))

61 plCndBellShape p_addition(points,number,f_mu,f_sigma);

62

63 /********************************************************** ************64 DECOMPOSITION

65 **********************************************************************/

66 // P(points number) = P(points | number) P(number)

67 plJointDistribution dice_jd(number^points,p_number*p_addition);

68

69 /********************************************************** ************

70 PROGRAM QUESTION

71 **********************************************************************/



74 int v;

75

76 // Get P(number | points)

77 dice_jd.ask(cnd_question,number,points);

78 coutv;80 result[points] = v;

81

82 // Get P(number | points = v)


84 plDistribution compiled_question;

85


87 cout


28/64



29/64

Chapter 4

Mixture models

Exercise 9: The population of a region on Equatorial Africa is composedof a non-Pygmy majority (84%) and a substantial Pygmy minority (16%).A non-pygmy adult has an average height of 1.55 meters with a standarddeviation of 7.5 cm. In contrast, a pygmy adult has an average height of1.30 meters with a standard deviation of 9.5 cm. The distribution of heightis assumed to be Gaussian.

Compute P(Height) for this region of Equatorial Africa.

29


30/64

30 CHAPTER 4. MIXTURE MODELS


32/64

32 CHAPTER 5. NAIVE BAYES

The assuming that each Mi is conditionally independent of every other Mjwith i =j leads to:

P(D|M1 M2...Mn) P(D)n

i=1

P(Mi|D)

Program 10:A sensor fusion program.

1 /*======================================================= ================

2 * Product :

3 * File : sensors.cpp


5 * Creation : Fri Nov 21 18:14:13 2008

6 *

7 *=========================================================== ============


9 * all rights reserved10 *=========================================================== ============

11 *

12 *------------------------- Description ---------------------------------

13 * This program simulates reading the distance of and object with two

14 * sensors. The two measures has a bellshape like distribution with

15 * two different variances. The goal is to find the more probable real

16 * distance

17 *----------------------------------------------------------- ------------

18 */

19

20 #define MIN_DIST 0

21 #define MAX_DIST 100

22 #define STD_DEV_1 10

23 #define STD_DEV_2 15

24

25 //#define MIN_MES_1 0

26 #define MIN_MES_1 (MIN_DIST-3*STD_DEV_1)

27 #define MAX_MES_1 (MAX_DIST+3*STD_DEV_1)

28

29 //#define MIN_MES_2 0

30 #define MIN_MES_2 (MIN_DIST-3*STD_DEV_2)

31 #define MAX_MES_2 (MAX_DIST+3*STD_DEV_2)

32

33 #include

34


36

37 int main ()

38 {

39 /**********************************************************************


41 **********************************************************************/

42 plIntegerType distance(MIN_DIST,MAX_DIST); // Distance type


33/64

33

43 plIntegerType measure1(MIN_MES_1, // Measure type for sensor 1

44 MAX_MES_1);

45 plIntegerType measure2(MIN_MES_2, // Measure type for sensor 2

46 MAX_MES_2);

47

48 plSymbol D("D",distance); // Real distance variable

49 plSymbol M1("M1",measure1); // sensor 1 measure

50 plSymbol M2("M2",measure2); // sensor 2 measure51

52

53 plVariable model_vars; // The variables of the model are the distance {D}

54 model_vars = D^M1^M2; // union measures 1 and 2 {M1, M2}

55

56

57 plValues model_values(model_vars); // A variable values for storing

58 // our data

59 /**********************************************************************


61 **********************************************************************/

62 plUniform P_dist(D); // D has an uniform distribution

63 plCndBellShape P_dist1(M1,D,STD_DEV_1); // M1 and M2 are bellshape like

64 plCndBellShape P_dist2(M2,D,STD_DEV_2); // distribution with a

65 // predefined variance

6667 /**********************************************************************

68 DECOMPOSITION

69 **********************************************************************/

70 // Defining the joint distribution P(D M1 M2) = P(D) P(M1|D) P(M2|D)

71 plJointDistribution my_model(model_vars,P_dist*P_dist1*P_dist2);

72

73

74 /**********************************************************************

75 PROGRAM QUESTION

76 **********************************************************************/

77 //Ask P( D | M1 M2)

78 plCndDistribution P_Cnd_dist;

79 my_model.ask(P_Cnd_dist,D,M1^M2); // Get P( D | M1 M2)

80

81 // Read measures from sensor A and B, then get P( D | M1=va M1=va)

8283 int v1, v2;

84

85 do {

86 coutv1;

88 }while (v1 < MIN_MES_1 || v1 > MAX_MES_1);

89

90 do {

91 coutv2;

93 }while (v2 < MIN_MES_2 || v2 > MAX_MES_2);

94

95 model_values[M1]=v1;

96 model_values[M2]=v2;

97

98 plDistribution P_dist_after_measure;


34/64


99 P_Cnd_dist.instantiate(P_dist_after_measure,

100 model_values); //Get P( D | M1=v1 M2=v2)

101

102 P_dist_after_measure.best(model_values); //Get the most probable distance

103

104 cout


35/64

35

35 // Set the spamer dictionary from the indicated file

36 spamer_dictionary my_dictionary(argv[1]);

37

38 /**********************************************************************


40 **********************************************************************/

41 plSymbol Spam("Spam",PL_BINARY_TYPE);

42 plArray W("W",PL_BINARY_TYPE,1,my_dictionary.get_number_of_words());43

44 /********************************************************* *************


46 **********************************************************************/

47 // Construct P(Spam) from the the data on the dictionary

48 plProbTable P_Spam(Spam,my_dictionary.spams);

49

50 // A tabable containing all the P(Wi | Spam)

51 vector P_W(my_dictionary.get_number_of_words());

52

53 // A list containig the product of

54 // P(W0 | Spam)*P(W1 | Spam)*...P(Wn | Spam)

55 plComputableObjectList all_PW;

56

57 // Construct each of the P(Wi | Spam) from the data on the dictionary

58 for (i=0; i


36/64


91

92 // Instantiate and compile the question

93 CndQuestion.instantiate(Question,W_values);

94 Question.compile(CompiledQuestion);

95

96 // Display the result

97 cout


37/64

Chapter 6

Dynamic Bayesian

Programming

6.1 Bayesian filters

Exercise 11: Use Program 9 to write a program that accepts a sequenceof throws of N dice with N 6. That is, your fellow takes the N diceand throw them t times. She let you know the number of points for each ofthe throws (without changing the number of dice). Write a ProBT programcomputing P(N| points1 points2 ... pointst).

6.2 Hidden Markov Models

For the previous exercise, consider that the number of dice from throw i

to throw i + 1 could change according to a random hidden variable Action.The hiden variable Action indicates one of three cases: add one die, takeout one die or stay with the same number of dice. Given a sequence ofnumber of points (corresponding to throwing the dice t times) we wold liketo computes the more probable number of dice at throw 1, 2,...,t. Otherwisestated, P(Nt| ponts1 points2 ...pointsn) is to be computed. The bayesiannetwork representing this model is shown in Figure 6.1. The distributionof P(Nt| Nt1 Action ) and that of P(Action) are shown in Figure 6.2.Assume that the initial number of dice (N0) is 3.

37


38/64

38 CHAPTER 6. DYNAMIC BAYESIAN PROGRAMMING

Program 12:The dice Hidden Markov Model.

1 /*======================================================= ================

2 * Product :

3 * File : diceHMM.cpp


6 *

7 *=========================================================== ============



10 *=========================================================== ============

11 *

12 *------------------------- Description ---------------------------------

13 * Given a sequence of number of points (corresponding to throwing the

14 * dice t times). This program computes the more probable number of dice

15 * at throw 1,2,...,t. The number of dice from throw i to throw i+1

16 * could change according to a random hidden variable "Action". The hiden

17 * variable "Action" indicates one of three cases: add one die, reduce one

18 * die or stay with the same number of dice.

19 *----------------------------------------------------------- ------------

20 */21

22 #include

23


25

26 #define SQRT_DIV35_12 1.7078251

27



30 mean[0] = 7*n[0]/2;

31

32 }

33




37

38 }

39

40 const unsigned int max_n = 6;

41

42 int main()

43 {

44 /***************************************************** *****************


46 **********************************************************************/

47 plIntegerType die_number(1,max_n); // Type for the maximum number

48 // of dice [1,2,...,max_n]

49 plIntegerType dice_sum(1,max_n*6); // Type for the sum [2,3,...,n*6]

50 plIntegerType HiddenVarType (-1, 1); // The type for the hidden variable

51

52 plSymbol Points("Points",dice_sum); // Variable space for the addition

53 plSymbol Previous_N("Prev_N",die_number);// Previous number of dice


39/64

6.2. HIDDEN MARKOV MODELS 39

54 plSymbol Current_N("Curr_N",die_number); // Current number of dice

55

56 plSymbol Action("Action", HiddenVarType); // The hidden variable

57

58 plValues result(Current_N^Points); // Values storing the # of dice

59 // and the addition

60 /********************************************************** ************

61 PARAMETRIC FORM SPECIFICATION62 **********************************************************************/

63 // P(Prevoius_N) at the begining we start with 3 dice

64 plProbValue tablePrevious[] = {0.0, 0.0, 1.0, 0.0, 0.0, 0.0};

65 plProbTable P_Previous_N(Previous_N, tablePrevious);

66

67 plProbValue tableAction[] = {0.333, 0.166, 0.5};

68 plProbTable P_Action(Action, tableAction);

69

70

71 plProbValue tableCurrent_N[] =

72 { 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, // N=1 A = -1

73 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, // N=1 A = 0

74 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, // N=1 A = 1

75 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, // N=2 A = -1

76 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, // N=2 A = 0

77 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, // N=2 A = 178 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, // N=3 A = -1

79 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, // N=3 A = 0

80 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, // N=3 A = 1

81 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, // N=4 A = -1

82 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, // N=4 A = 0

83 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, // N=4 A = 1

84 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, // N=5 A = -1

85 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, // N=5 A = 0

86 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, // N=5 A = 1

87 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, // N=6 A = -1

88 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, // N=6 A = 0

89 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, // N=6 A = 1

90 };

91 plDistributionTable P_Current_N(Current_N, Previous_N Action, tableCurrent_N);

92

93 cout


40/64


110

111 /***************************************************** *****************

112 PROGRAM QUESTION

113 ************************************************************ **********/



116 int v;

117118 // Get P(Current_N | Points)

119 dice_jd.ask(cnd_question,Current_N,Points);

120

121 unsigned int n=0;

122

123 coutn;

125

126 do {

127 n--;

128 coutv;

130 result[Points] = v;

131

132 // Get P(Current_N | Points = v)

133 cnd_question.instantiate(question,result);134 plDistribution compiled_question;

135


137 cout


41/64

6.2. HIDDEN MARKOV MODELS 41

Actiont

Nt1 Nt

Pointst

Figure 6.1: The dice Hidden Markov Model.


42/64


P(Nt|Nt1 Action )Nt1 Action N t

1 2 3 4 5 6

1 -1 1 0 0 0 0 0

1 0 1 0 0 0 0 0

1 1 0 1 0 0 0 0

2 -1 1 0 0 0 0 0

2 0 0 1 0 0 0 0

2 1 0 0 1 0 0 0

3 -1 0 1 0 0 0 03 0 0 0 1 0 0 0

3 1 0 0 0 1 0 0

4 -1 0 0 1 0 0 0

4 0 0 0 0 1 0 0

4 1 0 0 0 0 1 0

5 -1 0 0 0 1 0 0

5 0 0 0 0 0 1 0

5 1 0 0 0 0 0 1

6 -1 0 0 0 0 1 0

6 0 0 0 0 0 0 1

6 1 0 0 0 0 0 1

P(Action)-1 0 1

0.333 0.166 0.5

Figure 6.2: The distributionsP(Nt|Nt1 Action ) andP(Action) used forthe Bayesian Network on Figure 6.1.


43/64

Appendix A

Answers to exercises

Exercise 1: For each one of the cases, Line 20 of program dice.cpp mustbe changed as shown below:

i. plArray dice_set("Die",die_type,1,2);

ii. plArray dice_set("Die",die_type,1,5);

iii. plArray dice_set("Die",die_type,2,3,5);

iv. plArray dice_set("Die",die_type,3,3,5,2);

Exercise 2: Add the following code at the end of the file twoDice.cpp:

plValues PntsDieValues(Points^Die);

PntsDieValues.reset();

do{

cout


45/64

45

Exercise 5:

Program 13:The water-sprinkler program.

1 /*========================================================= ==============

2 * Product :3 * File : sprinkler.cpp


5 * Creation : Fri Nov 21 18:06:08 2008

6 *

7 *========================================================= ==============



10 *========================================================= ==============

11 *

12 *------------------------- Description ---------------------------------

13 * This contains the water-sprinkler model

14 *--------------------------------------------------------- --------------

15 */

16

17 #include

18 #include 19


21

22 int main() {

23 /********************************************************** ************


25 ********************************************************** ************/

26 plSymbol GC("GC",PL_BINARY_TYPE);

27 plSymbol R("R",PL_BINARY_TYPE);

28 plSymbol WG("WG",PL_BINARY_TYPE);

29 plSymbol S("S",PL_BINARY_TYPE);

30

31 /********************************************************** ************


33 ********************************************************** ************/

34 plProbValue T_GC[] = {0.5, 0.5};

35 plProbTable P_GC(GC,T_GC);

36

37 plProbValue T_R[] = {0.8, 0.2,

38 0.35, 0.65};

39 plDistributionTable P_R(R,GC,T_R);

40

41 plProbValue T_S[] = {0.5, 0.5,

42 0.9, 0.1};

43 plDistributionTable P_S(S,GC,T_S);

44

45 plProbValue T_WG[] = {1.0, 0.0,

46 0.1, 0.9,

47 0.1, 0.9,

48 0.01, 0.99};

49 plDistributionTable P_WG(WG,S^R,T_WG);

50

51 /********************************************************** ************


46/64


52 DECOMPOSITION

53 ************************************************************ **********/

54 plJointDistribution jd(GC^R^S WG, P_GC*P_R*P_S*P_WG);

55

56 /***************************************************** *****************

57 PROGRAM QUESTION

58 ************************************************************ **********/

59 plCndDistribution question;60 plDistribution inst_question, comp_question;

61

62 jd.ask(question, GC, WG^S);

63

64 plValues evidence(WG^S);

65 evidence[WG] = true;

66 evidence[S] = false;

67

68 question.instantiate(inst_question, evidence);

69 inst_question.compile(comp_question);

70

71 cout


47/64

47

EEmergency

JA John accepted

MA Mary accepted

AA Alice accepted

BA Bill accepted

JPJohn is present

MPMary is present

APAlice is present

VPVictor is present

BPBill is present

ii. The Bayesian program for Peters party is show in Figure A.1

PartyBN() =

8>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>:

Description

8>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>:

Specification

8>>>>>>>>>>>>>>>>>>>>>>>>>>>>>:

Relevant Variables:RI, RP, We, LI, E, JA, MA, AA, BA, JP, MP, AP, VP, BP

Decomposition:

P(RI RP We LI E JA MA AA BA JP MP AP V P BP| ) =

Decomposition

P(RI| )P(RP| )P(We| )P(LI| )P(E| )P(JA |RI )P(BA |LI )P(AA |We )P(AP|AA )P(MA |JA AA )P(MP|MA )P(VP|AA BA )P(JP|JA RP )P(BP|BA E )

Parametric Forms:See FigureA.2


Question:

P(JP MP AP VP BP| )

Figure A.1: Peters party Bayesian program. The variables are Rain oninvitations day (RI),Rain on Partys day(RP),Weekend invitation(We),Late invitation (LI), Emergency (E), John accepted (JA), Mary accepted(MA), Alice accepted(AA),Bill accepted(BA), John is present(JP), Maryis present(MP),Alice is present(AP),Victor is present(VP),Bill is present(BP)

iii. The Bayesian network is shown in Figure A.3

iv. The expressions for the questions are:


48/64


P(RI| )0 1

0.78 0.22

P(RP| )0 1

0.78 0.22

P(We| )0 1

0.72 0.28

P(LI| )0 1

0.7 0.3

P(E| )0 1

0.35 0.65

P(JA|RI )RI JA

0 1

0 0.1 0.9

1 0.6 0.4

P(BA|LI )LI BA

0 1

0 0.05 0.95

1 0.7 0.3

P(AA|We )We AA

0 1

0 0.6 0.4

1 0.2 0.8

P(AP| AA )AA AP

0 1

0 0.5 0.5

1 0.2 0.8

P(MA|JA AA )JA AA MA

0 1

0 0 0.5 0.5

0 1 0.15 0.85

1 0 0.05 0.95

1 1 0.95 0.05

P(MP| MA )MA MP

0 1

0 0.97 0.03

1 0.03 0.97

P(VP| AA BA )AA BA VP

0 1

0 0 0.3 0.7

0 1 0.6 0.41 0 0.1 0.9

1 1 0.0 1.0

P(JP| JA RP )JA RP JP

0 1

0 0 0.6 0.4

0 1 1.0 0.01 0 0.1 0.9

1 1 0.3 0.7

P(BP| BA E )BA E BP

0 1

0 0 0.8 0.2

0 1 1.0 0.01 0 0.05 0.95

1 1 1.0 0.0

Figure A.2: Parametrical forms of Peters party Bayesian program (SeeFigure A.1).


49/64

49

Invitationon weekend

It rains theday of the

Urgency inthe hospital

John is present Mary is present Alice is present Victor is present Bill is present

Late invitation

John Alice Bill

Mary

accepted accepted accepted

accepted

invitation

It rains theday of the

party

Figure A.3: The Peters party Bayesian network.

(a) What is the probability that it was raining when John receivedthe invitation knowing that Mary didnt attend the party andthat the party is on Monday?

P(RI =true|MP=true We=false )

(b) What is the probability that all Peters friends attend the party

knowing that it will take place on a sunny Saturday, knowingthat Bill received the invitation in time and no emergency waspresent at the hospital?

P(JP=true MP=true AP=true AP=true BP=true|RP=false We= true LI =false E=false)

(c) What is the probability that Alice, Victor and Bill attend theparty?

P(AP=true VP=true BP=true| )


50/64


(d) Alice answer the phone at Peters house, Hi John. What isthe probability that Mary and Victor attended the party? (Note:No, no, no, John is not calling from a cell phone).

P(MP=true VP=true|AP=true JP=false )

v. The ProBT Bayesian program modeling the Peters problem appearsbelow:


51/64

51

Program 14:Peters problem .

1 /*======================================================== ===============

2 * Product :

3 * File : PartyBN.cpp

4 * Author : Juan-Manuel Ahuactzin5 * Creation : Wed Nov 26 16:54:59 2008

6 *

7 *======================================================== ===============



10 *======================================================== ===============

11 *

12 *------------------------- Description ---------------------------------

13 * This program solves the Peters party problem

14 *-------------------------------------------------------- ---------------

15 */

16

17 #include

18 #include

19

20 using namespace std;21

22 int main() {

23

24 /********************************************************* *************


26 ********************************************************* *************/

27 plSymbol RainOnInv("RainOnInv", PL_BINARY_TYPE);

28 plSymbol RainOnParty("RainOnParty",PL_BINARY_TYPE);

29 plSymbol WE_Invitation("WE_Invitation",PL_BINARY_TYPE);

30 plSymbol LateInv("LateInv",PL_BINARY_TYPE);

31 plSymbol Emergency("Emergency",PL_BINARY_TYPE);

32 plSymbol JohnAccepted("JohnAccepted",PL_BINARY_TYPE);

33 plSymbol MaryAccepted("MaryAccepted",PL_BINARY_TYPE);

34 plSymbol AliceAccepted("AliceAccepted",PL_BINARY_TYPE);

35 plSymbol BillAccepted("BillAccepted",PL_BINARY_TYPE);

36 plSymbol JohnIsPresent("JohnIsPresent",PL_BINARY_TYPE);

37 plSymbol MaryIsPresent("MaryIsPresent",PL_BINARY_TYPE);

38 plSymbol AliceIsPresent("AliceIsPresent",PL_BINARY_TYPE);

39 plSymbol VictorIsPresent("VictorIsPresent",PL_BINARY_TYPE);

40 plSymbol BillIsPresent("BillIsPresent",PL_BINARY_TYPE);

41

42 /********************************************************* *************


44 ********************************************************* *************/

45 plProbValue tableRain[] = {0.78, 0.22};

46

47 plProbTable P_RI(RainOnInv, tableRain);

48 cout


52/64


54 cout


53/64

53

110 plProbValue tableBP[] = {0.8, 0.2,

111 1.0, 0.0,

112 0.05, 0.95,

113 1.0, 0.0};

114 plDistributionTable P_BP(BillIsPresent, BillAccepted^Emergency, tableBP);

115 cout


54/64


166 values[AliceIsPresent]=true;

167 values[BillIsPresent]=true;

168 values[VictorIsPresent]=true;

169

170 cout


55/64

55

Exercise 7:

Program 15:The sum of N dice.

1 /*========================================================= ==============

2 * Product :3 * File : addDice.cpp


5 * Creation : 2002-Oct-30 19:29

6 *

7 *========================================================= ==============



10 *========================================================= ==============

11 *

12 *------------------------- Description ---------------------------------

13 * This program shows the use of external functions by means of C++ functions

14 * The construction of a functional dirac is also shown.

15 * The program gives the possible values of each of the dice given the sum of

16 * points.

17 *--------------------------------------------------------- --------------

18 */19

20 #include

21


23

24 void add_dice(plValues &dice_addition, const plValues &die) {

25 unsigned int n_dice; // Number of dice

26 unsigned int sum=0; // sum of points

27 unsigned int i;

28

29 n_dice = die.size(); // Get the number of dice

30

31 for(i=0;i


56/64


52 number_of_dice*6);// Sum type [n,n+1,...,n*6]


54 plArray dice("Die",die_type,1,

55 number_of_dice); // Variable space for the dice

56

57 plValues result(dice^points); // Values storing the result of the

58 // dice and the addition

5960 /**********************************************************************

61 Writing the joint distribution

62 ***********************************************************************/

63

64 // P(Die0 Die1 ... Die(n-1)) = Uniform(Die0 Die1 ... Die(n-1))

65 plUniform p_dice(dice);

66

67 // Create the external function

68 plExternalFunction sum(points,dice,add_dice);

69

70 // P(points=p | Die0=die0 Die1=die1 ... Die(n-1)=die(n-1)) =

71 // 1 if points = add_dice(die0,die1,...,die(n-1)) else 0

72 plFunctionalDirac p_addition(points,dice,sum);

73

74 // P(Die0 Die1...Die(n-1) points)=

75 // P(Die0 Die1 ... Die(n-1))76 // P(points | Die0 Die1...Die(n-1))

77 plJointDistribution dice_jd(dice^points,p_dice*p_addition);

78

79 /**********************************************************************

80 Making a question P(Die0 Die1 ... Die(n-1)| points = v)

81 ***********************************************************************/

82



85 int v;

86

87 // Get P(Die0 Die1 ... Die(n-1) | points )

88 dice_jd.ask(cnd_question,dice,points);

89 coutv;

91 result[points] = v;92

93 // Get P(Die0 Die1 ... Die(n-1) | points=v)


95

96 /**********************************************************************

97 Tabulate the result of the question

98 ***********************************************************************/

99

100 cout


57/64

57

Exercise 8: At the beginning of Program 14 (before the main) add thefollowing lines:

void f_N_persons(plValues &tot_attended, const plValues &attended) {

unsigned int i, n;

// Count the total number of persons who attended the partyn = 0 ;

for(i=0; i


58/64


59/64

59

0

0.005

0.01

0.015

0.02

0.025

0.03

0.035

0.04

0.045

40 60 80 100 120 140 160 180 200

P(Height)

Height

P(Height) = { Sum_{Pygmy} {P(Pygmy)P(Height | Pygmy) } }

Figure A.4: Output of Program 16: the distribution of P(Height) for theregion of Equatorial Africa described on Exercise 9.

51 /********************************************************** ************

52 PROGRAM QUESTION

53 ********************************************************** ************/

54 // Compute and plot P(Height)


56

57 jd.ask(question, Height);

58

59 question.plot("Height.gplot");60 }

The output of Program 16 is shown in Figure A.4.

Exercise 10 A third sensor id added easily mainly by adding the followinglines:

plIntegerType measure3(MIN_MES_3, // Measure type for sensor 3

MAX_MES_3);

plSymbol M3("M3",measure3); // sensor 3 measure

model_vars = D^M1^M2^M3; // union measures 1,2 and 3 {M1, M2, M3}


60/64


plCndBellShape P_dist3(M3,D,STD_DEV_3); // distribution with a

// predefined variance

then in the joint distribution you must add:

plJointDistribution my_model(model_vars,P_dist*P_dist1*P_dist2*P_d ist3);

Exercise 11

Program 17:The dice filter program.

1 /*======================================================= ================

2 * Product :

3 * File : diceFilter.cpp


5 * Creation : 2008-Oct-02 16:16

6 *7 *=========================================================== ============



10 *=========================================================== ============

11 *

12 *------------------------- Description ---------------------------------

13 * This program computes the more probable number of dice given the

14 * sequence of number of points corresponding to throwing the dice t

15 * times.

16 *----------------------------------------------------------- ------------

17 */

18

19 #include

20


22

23 #define SQRT_DIV35_12 1.7078251

24

25



28 mean[0] = 7*n[0]/2;

29 }

30




34 }

35

36 int main() {

37 /***************************************************** *****************


39 **********************************************************************/


61/64

61

40 unsigned int max_n;

41 coutmax_n;

43

44 plIntegerType die_number(1,max_n); // Type for the maximum number

45 // of dice [1,2,...,max_n]

46 plIntegerType dice_sum(1,max_n*6); // Type for the sum [2,3,...,n*6]

47 plSymbol points("Addition",dice_sum); // Variable space for the addition48 plSymbol number("n",die_number); // Variable space for the

49 // selected number of dice

50

51 plValues result(number^points); // Values storing the # of dice

52 // and the addition

53 /********************************************************** ************


55 **********************************************************************/

56 // P(number) = uniform(number)

57 plUniform p_number(number);

58

59 // Create the external functions to compute the mean and the

60 // standard deviation

61 plExternalFunction f_mu(number,f_mean);

62 plExternalFunction f_sigma(number,f_std);

6364 // P(points | number) = CndBellShape(points,f_mu(number),f_sigma(number))

65 plCndBellShape p_addition(points,number,f_mu,f_sigma);

66

67 /********************************************************** ************

68 DECOMPOSITION

69 ********************************************************** ************/

70 // P(points number) = P(points | number) P(number)

71 plJointDistribution dice_jd(number^points,p_number*p_addition);

72 dice_jd.draw_graph("addDice3.fig");

73

74 /********************************************************** ************

75 PROGRAM QUESTION

76 ********************************************************** ************/



79 int v;80

81 // Get P(number | points)

82 dice_jd.ask(cnd_question,number,points);

83

84 unsigned int t=0;

85

86 coutt;

88

89 do {

90 t--;

91 coutv;

93 result[points] = v;

94

95 // Get P(number | points = v)


62/64



97 plDistribution compiled_question;

98


100 cout


63/64

63

bp with probt

Documents