Release ZERO.0.1 of package RefereeToolbox

03/12/2010 ∙ by Frederic Dambreville, et al. ∙ 0

RefereeToolbox is a java package implementing combination operators for fusing evidences. It is downloadable from: http://refereefunction.fredericdambreville.com/releases RefereeToolbox is based on an interpretation of the fusion rules by means of Referee Functions. This approach implies a dissociation between the definition of the combination and its actual implementation, which is common to all referee-based combinations. As a result, RefereeToolbox is designed with the aim to be generic and evolutive.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Description

RefereeToolbox is a java package implementing combination operators for fusing evidences. It is downloadable from:

http://refereefunction.fredericdambreville.com/releases

RefereeToolbox is based on an interpretation of the fusion rules by means of Referee Functions (refer to 2). This approach implies a dissociation between the definition of the combination and its actual implementation, which is common to all referee-based combinations. As a result, RefereeToolbox is designed with the aim to be generic and evolutive. It is composed of three distinct classes of objects:

  • A class for the logical representation of the information; this class is generic and incremental; are yet implemented structures as:

    • Powerset,

    • Free Boolean algebra,

    • Superpowerset,

    • Open/closed hyperpowerset,

    • make yours!

  • A class for defining the referee functions; this class is generic and incremental; are yet defined referee functions for:

    • Dempster-Shafer combination,

    • Disjunctive combination,

    • Dubois&Prade combination,

    • PCR6 combination,

    • PCR# combination,

    • make yours!

  • A class defining the Basic Belief Assignment, and related processes; this class is generic and incremental; two referee-based approaches are implemented for computing combinations:

    • An exact approach associated with a relaxation of the focal elements, so as to handle the combinatorics,

    • A sampling-based approach.

The generic implementation of RefereeToolbox makes possible to combine these three classes and their instances without restriction.

2 What is a referee function?

For an introduction to the theory of referee function, please refer to [3].

2.1 Basic Belief Assignment

Let be a complete distributive lattice. A basic belief assignment [1, 2] is a mapping from elements of onto such that:

(1)

2.2 Referee function

Definition.

A referee function over for sources of information and with context is a mapping defined on propositions  , which satisfies for any :

A referee function for sources of information is also called a -ary referee function. The quantity is called a conditional arbitrament between in favor of . Notice that is not necessary one of the propositions  ; typically, it could be a combination of them. The case is called the rejection case.

Fusion rule.

Let be given basic belief assignments (bba) and a -ary referee function with context  . Then, the fused bba based on the referee is constructed as follows:

(2)

The value is called the rejection rate.

2.3 Examples of referee functions

Dempster-shafer rule.

Let be given sources of information characterized by their bbas . The fused bba obtained from by means of Dempster-Shafer fusion rule [1, 2] is defined by:

where corresponds to the conjunctive consensus:

Definition by referee function.

The definition of a referee function for Dempster-Shafer is immediate:

References

  • [1] Dempster A.P.,

    Upper and Lower probabilities induced by a multivalued mapping

    , Annals of Mathematical Statistics, vol. 83, pp. 325–339, 1967.
  • [2] Shafer G., A mathematical theory of evidence, Princeton University Press, 1976.
  • [3] Frédéric Dambreville, Chap. 6: Definition of evidence fusion rules based on referee functions, in Smarandache F. & Dezert J., Editors, Applications and Advances on DSmT for Information Fusion (Collected Works), Vol. 3, American Research Press, 2009.

3 Code

1/*
2 *   ArrayBoolean.java : part of package RefereeToolbox; Implementation of
3 *          Boolean algebra.
4 *******************************************************************************
5 *   Copyright (c) 2010 Frédéric Dambreville
6 *
7 *   Author:    Frédéric Dambreville <http://email.fredericdambreville.com>
8 *
9 *   This file is part of RefereeToolbox.
10 *
11 *   RefereeToolbox is free software: you can redistribute it and/or modify
12 *   it under the terms of the GNU General Public License as published by
13 *   the Free Software Foundation, either version 3 of the License, or
14 *   (at your option) any later version.
15 *
16 *   RefereeToolbox is distributed in the hope that it will be useful,
17 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
18 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19 *   GNU General Public License for more details.
20 *
21 *   You should have received a copy of the GNU General Public License
22 *   along with RefereeToolbox.  If not, see <http://www.gnu.org/licenses/>.
23 *******************************************************************************
24 */
25
26package RefereeToolbox;
27
28/**
29 * Implementation of a Boolean structure by means of an array of {@code long}.
30 * The AND and OR operators are inherited from the operators {@code & } and {@code | }
31 * working on {@code long}.
32 * <i>zero</i> is defined by zeroing all bits. <i>one</i> is defined by setting to
33 * 1 all active bits; the right bits of the {@code long } vector may be inactive,
34 * depending on the size of the Lattice.
35 * The complement/cocomplement operators are inherited from the operators {@code ~ }
36 *  working on {@code long}; exceeding bits are masked by a AND with <i>one</i>.
37 *
38 * @author      <A href="http://email.fredericdambreville.com">Frédéric Dambreville</A>
39 *
40 *
41 *
42 * <BR><BR><table border=’1’ cellPadding=’4’><tr><td>
43 * <font color="#008000" style="font-family: georgia">
44 *   Copyright (c) 2010 Frédéric Dambreville<BR>
45 * <BR>
46 *   RefereeToolbox is free software: you can redistribute it and/or modify
47 *   it under the terms of the GNU General Public License as published by
48 *   the Free Software Foundation, either version 3 of the License, or
49 *   (at your option) any later version.<BR>
50 * <BR>
51 *   RefereeToolbox is distributed in the hope that it will be useful,
52 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
53 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
54 *   GNU General Public License for more details.<BR>
55 * <BR>
56 *   You should have received a copy of the GNU General Public License
57 *   along with RefereeToolbox. If not, see
59 * </font></table><BR>
60 *
61 */
62 public class ArrayBoolean<L extends ArrayBoolean<L>>
63        extends ArrayLattice<L> implements ComplementedLattice<L> {
64
65
66    //////////////////////////////////////////////////:
67    // public part
68    ///////////////
69
70    /**
71     * Compute the <b>complement</b> of <i>aProposition</i> and store the result within
72     * <i>this</i>.
73     * The complement/cocomplement operators are inherited from the operators {@code ~ }
74     * working on {@code long}; exceeding bits are masked by a AND with <i>one</i>.
75     * The complement and cocomplement are the same for {@link ArrayBoolean }
76     * <BR><BR>
77     * <b>Documentation inherited from {@link ComplementedLattice }:</b><BR>
78     * {@inheritDoc}
79     *
80     */
81    public L complement(L aProposition) {
82        long[] rightmem=aProposition._memory;
83        int i;
84        for(i=0;i<=size_mem_1;i++)  _memory[i]=~rightmem[i];
85        _memory[size_mem_1]&=highest_long_one;
86        return (L) this;
87    }
88
89    /**
90     * Compute the <b>complement</b> of <i>aProposition</i> and store the result within
91     * <i>this</i>.
92     * The complement/cocomplement operators are inherited from the operators {@code ~ }
93     * working on {@code long}; exceeding bits are masked by a AND with <i>one</i>.
94     * The complement and cocomplement are the same for {@link ArrayBoolean }
95     * <BR><BR>
96     * <b>Documentation inherited from {@link ComplementedLattice }:</b><BR>
97     * {@inheritDoc}
98     *
99     */
100    public L complement() {
101        int i;
102        for(i=0;i<=size_mem_1;i++)  _memory[i]=~_memory[i];
103        _memory[size_mem_1]&=highest_long_one;
104        return (L) this;
105    }
106
107    /**
108     * Compute the <b>complement</b> of <i>aProposition</i> and store the result within
109     * <i>this</i>.
110     * The complement/cocomplement operators are inherited from the operators {@code ~ }
111     * working on {@code long}; exceeding bits are masked by a AND with <i>one</i>.
112     * The complement and cocomplement are the same for {@link ArrayBoolean }
113     * <BR><BR>
114     * <b>Documentation inherited from {@link ComplementedLattice }:</b><BR>
115     * {@inheritDoc}
116     *
117     */
118    public L cocomplement(L aProposition) {
119        return complement(aProposition);
120    }
121
122    /**
123     * Compute the <b>complement</b> of <i>aProposition</i> and store the result within
124     * <i>this</i>.
125     * The complement/cocomplement operators are inherited from the operators {@code ~ }
126     * working on {@code long}; exceeding bits are masked by a AND with <i>one</i>.
127     * The complement and cocomplement are the same for {@link ArrayBoolean }
128     * <BR><BR>
129     * <b>Documentation inherited from {@link ComplementedLattice }:</b><BR>
130     * {@inheritDoc}
131     *
132     */
133    public L cocomplement() {
134        return complement();
135    }
136
137}
Source Code: ArrayBoolean.java
1/*
2 *   ArrayLattice.java : part of package RefereeToolbox; Implementation of
3 *          Lattice.
4 *******************************************************************************
5 *   Copyright (c) 2010 Frédéric Dambreville
6 *
7 *   Author:    Frédéric Dambreville <http://email.fredericdambreville.com>
8 *
9 *   This file is part of RefereeToolbox.
10 *
11 *   RefereeToolbox is free software: you can redistribute it and/or modify
12 *   it under the terms of the GNU General Public License as published by
13 *   the Free Software Foundation, either version 3 of the License, or
14 *   (at your option) any later version.
15 *
16 *   RefereeToolbox is distributed in the hope that it will be useful,
17 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
18 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19 *   GNU General Public License for more details.
20 *
21 *   You should have received a copy of the GNU General Public License
22 *   along with RefereeToolbox. If not, see <http://www.gnu.org/licenses/>.
23 *******************************************************************************
24 */
25
26package RefereeToolbox;
27
28/**
29 * Implementation of a Lattice structure by means of an array of {@code long}.
30 * The AND and OR operators are inherited from the operators {@code & } and {@code | }
31 * working on {@code long}.
32 * <i>zero</i> is defined by zeroing all bits. <i>one</i> is defined by setting to
33 * 1 all active bits; the right bits of the {@code long } vector may be inactive,
34 * depending on the size of the Lattice.
35 *
36 * @author      <A href="http://email.fredericdambreville.com">Frédéric Dambreville</A>
37 *
38 *
39 *
40 * <BR><BR><table border=’1’ cellPadding=’4’><tr><td>
41 * <font color="#008000" style="font-family: georgia">
42 *   Copyright (c) 2010 Frédéric Dambreville<BR>
43 * <BR>
44 *   RefereeToolbox is free software: you can redistribute it and/or modify
45 *   it under the terms of the GNU General Public License as published by
46 *   the Free Software Foundation, either version 3 of the License, or
47 *   (at your option) any later version.<BR>
48 * <BR>
49 *   RefereeToolbox is distributed in the hope that it will be useful,
50 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
51 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
52 *   GNU General Public License for more details.<BR>
53 * <BR>
54 *   You should have received a copy of the GNU General Public License
55 *   along with RefereeToolbox. If not, see
57 * </font></table><BR>
58 *
59 */
60public class ArrayLattice<L extends ArrayLattice<L>>
61        extends LatticeCommon<L> {
62
63    protected long[] _memory=null;
64
65    protected int size_mem_1=-1; // undefined, by default
66    protected long highest_long_one;
67
68
69    //////////////////////////////////////////////////:
70    // public part
71    ///////////////
72
73/**
74 * Return a representation of the state of <i>this</i> printed as a String. States
75 * of this class are printed as the concatenation of the Hexadecimal representation
76 * of the <i>long</i> array.
77 *
78 */
79    @Override
80    public String state() {
81        String theState="";
82        String tmp;
83        int i;
84        for(i=size_mem_1;i>=0;i–) {
85            tmp=Long.toHexString(_memory[i]);
86            theState+="x"+"0000000000000000".substring(0, 16-tmp.length())+tmp;
87        }
88        return theState;
89    }
90
91/**
92 * Set <i>this</i> to zero, the neutral element for
93 * {@link Lattice#or(java.lang.Object, java.lang.Object) }.
94 * N.B. It is necessary to call {@link Lattice#size } or
95 * {@link Lattice#size(java.lang.Object) } before any first use of this
96 * method.
97 *
98 */
99    @Override
100    public L zero() {
101        int i;
102        for(i=0;i<=size_mem_1;i++) _memory[i]=0;
103        return (L) this;
104    }
105
106/**
107 * Set <i>this</i> to one, the neutral element for
108 * {@link Lattice#and(java.lang.Object, java.lang.Object) }.
109 * N.B. It is necessary to call {@link Lattice#size } or
110 * {@link Lattice#size(java.lang.Object) } before any first use of this method.
111 *
112 */
113    @Override
114    public L one() {
115        int i;
116        for(i=0;i<size_mem_1;i++)  _memory[i]=0xFFFFFFFFFFFFFFFFL;
117        _memory[i]=highest_long_one;
118        return (L) this;
119    }
120
121/**
122 * Compute the AND of <i>left</i> and <i>right</i> and store the result within <i>this</i>.
123 *
124 */
125    @Override
126    public L and(L left, L right) {
127        long[] leftmem=left._memory;
128        long[] rightmem=right._memory;
129        int i;
130        for(i=0;i<=size_mem_1;i++)  _memory[i]=leftmem[i]&rightmem[i];
131        return (L) this;
132    }
133
134/**
135 * Compute the OR of <i>left</i> and <i>right</i> and store the result within <i>this</i>.
136 *
137 */
138    @Override
139    public L or(L left, L right) {
140        long[] leftmem=left._memory;
141        long[] rightmem=right._memory;
142        int i;
143        for(i=0;i<=size_mem_1;i++)  _memory[i]=leftmem[i]|rightmem[i];
144        return (L) this;
145    }
146
147/**
148 * Answer <i>true</i> if the proposition stored within <i>this</i> intersects the
149 * proposition contained within <i>aProposition</i> (<i>i.e.</i> the intersection
150 * of both propositions is not <i>zero</i>). Answer <i>false</i> otherwise.
151 *
152 */
153    @Override
154    public  boolean intersects(L aProposition) {
155        long[] rightmem=aProposition._memory;
156        int i;
157        for(i=0;i<=size_mem_1;i++) {
158            if((_memory[i]&rightmem[i])!=0) return true;
159        }
160        return false;
161    }
162
163/**
164 * Answer <i>true</i> if the proposition stored within <i>this</i> contains the
165 * proposition contained within <i>aProposition</i>. Answer <i>false</i> otherwise.
166 *
167 */
168    @Override
169    public boolean contains(L aProposition) {
170        long[] rightmem=aProposition._memory;
171        int i;
172        for(i=0;i<=size_mem_1;i++) {
173            if((_memory[i]&rightmem[i])!=rightmem[i]) return false;
174        }
175        return true;
176    }
177
178/**
179 * Compare <i>this</i> to <i>aProposition</i> and answer negative integer, zero,
180 * positive integer as <i>this</i> is less than, equal to, or greater than
181 * <i>aProposition</i>.
182 * This comparison is related to a total ordering of the proposition; <em>it is not
183 * related to the partial order implied by the logical operators AND and OR.</em>
184 *
185 */
186    @Override
187    public int compareTo(L aProposition) {
188        long[] rightmem=aProposition._memory;
189        int i;
190        long delta;
191        for(i=0;i<=size_mem_1;i++) {
192            delta=_memory[i]-rightmem[i];
193            if(delta>0) return 1;
194            if(delta<0) return -1;
195        }
196        return 0;
197    }
198
199/**
200 * Resize <i>this</i> at the same size than <i>input</i>.
201 *
202 */
203    @Override
204    public L size(L input) {
205        size_mem_1=input.size_mem_1;
206        highest_long_one=input.highest_long_one;
207        _memory=new long[size_mem_1+1];
208        return (L) this;
209    }
210
211
212 /**
213 * Do an exact copy of input into <i>this</i>.
214 *
215 */
216    @Override
217    public L duplicate(L input) {
218        size(input);
219        int i;
220        for(i=0;i<=size_mem_1;i++) _memory[i]=input._memory[i];
221        return (L) this;
222    }
223
224}
Source Code: ArrayLattice.java
1/*
2 *   Assignment.java : part of package RefereeToolbox; Class encoding an
3 *          assignment of a basic belief to a proposition.
4 *******************************************************************************
5 *   Copyright (c) 2010 Frédéric Dambreville
6 *
7 *   Author:    Frédéric Dambreville <http://email.fredericdambreville.com>
8 *
9 *   This file is part of RefereeToolbox.
10 *
11 *   RefereeToolbox is free software: you can redistribute it and/or modify
12 *   it under the terms of the GNU General Public License as published by
13 *   the Free Software Foundation, either version 3 of the License, or
14 *   (at your option) any later version.
15 *
16 *   RefereeToolbox is distributed in the hope that it will be useful,
17 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
18 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19 *   GNU General Public License for more details.
20 *
21 *   You should have received a copy of the GNU General Public License
22 *   along with RefereeToolbox. If not, see <http://www.gnu.org/licenses/>.
23 *******************************************************************************
24 */
25
26package RefereeToolbox;
27
28/**
29 * Container instrumental to all classes implementing {@link minAssignment } and
30 * to class RefereeFunctionDefault and its subclasses;
31 * a structure encoding an assignment of a basic belief to a proposition.
32 *
33 * @author      <A href="http://email.fredericdambreville.com">Frédéric Dambreville</A>
34 *
35 *
36 *
37 * <BR><BR><table border=’1’ cellPadding=’4’><tr><td>
38 * <font color="#008000" style="font-family: georgia">
39 *   Copyright (c) 2010 Frédéric Dambreville<BR>
40 * <BR>
41 *   RefereeToolbox is free software: you can redistribute it and/or modify
42 *   it under the terms of the GNU General Public License as published by
43 *   the Free Software Foundation, either version 3 of the License, or
44 *   (at your option) any later version.<BR>
45 * <BR>
46 *   RefereeToolbox is distributed in the hope that it will be useful,
47 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
48 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
49 *   GNU General Public License for more details.<BR>
50 * <BR>
51 *   You should have received a copy of the GNU General Public License
52 *   along with RefereeToolbox. If not, see
54 * </font></table><BR>
55 *
56 */
57    public class Assignment<Prop> {
58/**
59 * This subfield stores the proposition of the assignment typed {@link Assignment }.
60 *
61 */
62        public Prop attribute;
63/**
64 * This subfield stores the value of the assignment.
65 *
66 */
67        public Double value;
68    }
Source Code: Assignment.java
1/*
2 *   BasicBeliefAssignment.java : part of package RefereeToolbox; Interface for
3 *          Basic Belief Assigments.
4 *******************************************************************************
5 *   Copyright (c) 2010 Frédéric Dambreville
6 *
7 *   Author:    Frédéric Dambreville <http://email.fredericdambreville.com>
8 *
9 *   This file is part of RefereeToolbox.
10 *
11 *   RefereeToolbox is free software: you can redistribute it and/or modify
12 *   it under the terms of the GNU General Public License as published by
13 *   the Free Software Foundation, either version 3 of the License, or
14 *   (at your option) any later version.
15 *
16 *   RefereeToolbox is distributed in the hope that it will be useful,
17 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
18 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19 *   GNU General Public License for more details.
20 *
21 *   You should have received a copy of the GNU General Public License
22 *   along with RefereeToolbox. If not, see <http://www.gnu.org/licenses/>.
23 *******************************************************************************
24 */
25
26package RefereeToolbox;
27
28import java.util.*;
29
30/**
31 * Contains the minimal declaration for classes managing belief assignment
32 * structures, belief assignment processes and fusers.
33 * This interface is implemented by all the these classes.
34 *
35 * @author      <A href="http://email.fredericdambreville.com">Frédéric Dambreville</A>
36 *
37 *
38 *
39 * <BR><BR><table border=’1’ cellPadding=’4’><tr><td>
40 * <font color="#008000" style="font-family: georgia">
41 *   Copyright (c) 2010 Frédéric Dambreville<BR>
42 * <BR>
43 *   RefereeToolbox is free software: you can redistribute it and/or modify
44 *   it under the terms of the GNU General Public License as published by
45 *   the Free Software Foundation, either version 3 of the License, or
46 *   (at your option) any later version.<BR>
47 * <BR>
48 *   RefereeToolbox is distributed in the hope that it will be useful,
49 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
50 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
51 *   GNU General Public License for more details.<BR>
52 * <BR>
53 *   You should have received a copy of the GNU General Public License
54 *   along with RefereeToolbox. If not, see
56 * </font></table><BR>
57 *
58 */
59public interface BasicBeliefAssignment<Prop extends Lattice<Prop>,
60                        B extends BasicBeliefAssignment<Prop,B> >
61                                        extends minAssignment<Prop> , Cloneable {
62
63/**
64 * Clear the assignments stored within {@link BasicBeliefAssignment }, and
65 * store new assignments from the collection of assignment, <i>anAssignmentTab</i>.
66 *
67 */
68    boolean load(Collection<Assignment<Prop>> anAssignmentTab);
69
70/**
71 * Do an exact copy of input into <i>this</i>.
72 *
73 */
74    B duplicate(B input); // make this a duplicate of input
75
76/**
77 * Create and return an instance of <i>this</i> (i.e. work like a <b>new</b> on
78 * the Class of <i>this</i>).
79 * N.B. {@link BasicBeliefAssignment#instance() } cannot be defined for generic
80 * classes but <u>is necessary</u> for some methods. <u>It has to be defined with
81 * the non generic (typically final) sub-classes</u>.
82 * <br><br>
83 * For a given non generic sub-class <i>myNonGenericSubclass</i>, a typical
84 * definition of {@link BasicBeliefAssignment#instance() } is as follows:
85 * <br><br>
86 * <font color="#004488"><code>
87 * {@code @Override}
88 * <br>
89 * public myNonGenericSubclass instance() { return new myNonGenericSubclass(); }
90 * </code></font>
91 *
92 */
93    B instance();
94
95/**
96 * Create  a clone of <i>this</i>.
97 *
98 */
99    B clone();
100
101/**
102 * Make a mix of the basic belief assignments stored within the entry, <i>bbaIn</i>
103 * according to their respective weight <i>weight</i>. This mix is stored into <i>this</i>.
104 *
105 */
106    B mix(ArrayList<B> bbaIn, double[] weight);
107
108/**
109 * Called each time a change is done to <i>this</i>. This is usefull for processes which need an
110 * initialization after each change of the assignments. Typically, the
111 * sampling methods require an action of {@link BasicBeliefAssignment#update_notification() }
112 * in order to decide for a new computation of the sampling tables, which are made
113 * necessary by a change of the assignments.
114 *
115 */
116    void update_notification(); //
117
118/**
119 * Return a representation of the state of <i>this</i> printed as
120 * a String. Typically, this state is the list of all stored assignments (proposition
121 * and value). Depending on the parameter <i>choix</i> in entry, the representation
122 * is modified as folllows:<br><br>
123 * <i>choix==0</i>    Nothing is printed.
124 * <br>
125 *<i>choix==1</i>    Assignments are printed in increasing order of their
126 * propositions,
127 * <br>
128 *<i>choix==2</i>    Assignments are printed in decreasing order of their
129 * value,
130 * <br>
131 *<i>choix==3</i>    Do both print in that order.
132 * <br>
133 *
134 */
135    String state(int choix); // a string representing the state of the BBA
136
137/**
138 * Remove all assignments from <i>this</i>. The class instance is cleared.
139 *
140 */
141    void clear();
142
143/**
144 * Add an assignment characterized by a proposition <i>aProposition</i> and a value
145 * <i>anAssignmentValue</i> to <i>this</i>.
146 * If an assignment already exists for <i>aProposition</i>, say with value <i>theOldValue</i>,
147 * then the new assignement of <i>aProposition</i> is stored with value
148 * <i>theOldValue+anAssignmentValue</i>.
149 *
150 */
151    boolean add(Prop aProposition, double anAssignmentValue);
152
153/**
154 * Do exactly as {@link BasicBeliefAssignment#add(RefereeToolbox.Lattice, double) }
155 * but takes an entry of type {@link Assignment }, which is actually
156 * equivalent.
157 *
158 */
159    boolean add(Assignment<Prop> anAssignment);
160
161/**
162 * Add all assignments of collection <i>assignTab</i> to <i>this</i>.
163 * This method is equivalent to applying
164 * {@link BasicBeliefAssignment#add(RefereeToolbox.Assignment) }
165 * to each assignment of collection <i>assignTab</i>.
166 *
167 */
168    boolean addAll(Collection<Assignment<Prop>> assignTab);
169
170/**
171 * Remove the assignment related to proposition <i>aProposition</i>, if there is
172 * such assignment stored within <i>this</i>.
173 * Return the value assigned to the proposition.
174 *
175 */
176    double remove(Prop aProposition);
177}
Source Code: BasicBeliefAssignment.java
1/*
2 *   BBACommon.java : part of package RefereeToolbox; Basical implementation of
3 *          the Basic Belief Assigment.
4 *******************************************************************************
5 *   Copyright (c) 2010 Frédéric Dambreville
6 *
7 *   Author:    Frédéric Dambreville <http://email.fredericdambreville.com>
8 *
9 *   This file is part of RefereeToolbox.
10 *
11 *   RefereeToolbox is free software: you can redistribute it and/or modify
12 *   it under the terms of the GNU General Public License as published by
13 *   the Free Software Foundation, either version 3 of the License, or
14 *   (at your option) any later version.
15 *
16 *   RefereeToolbox is distributed in the hope that it will be useful,
17 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
18 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19 *   GNU General Public License for more details.
20 *
21 *   You should have received a copy of the GNU General Public License
22 *   along with RefereeToolbox. If not, see <http://www.gnu.org/licenses/>.
23 *******************************************************************************
24 */
25
26package RefereeToolbox;
27
28import java.util.*;
29
30/**
31 * Basical implementation of the Basic Belief Assigment structure.
32 *
33 * @author      <A href="http://email.fredericdambreville.com">Frédéric Dambreville</A>
34 *
35 *
36 *
37 * <BR><BR><table border=’1’ cellPadding=’4’><tr><td>
38 * <font color="#008000" style="font-family: georgia">
39 *   Copyright (c) 2010 Frédéric Dambreville<BR>
40 * <BR>
41 *   RefereeToolbox is free software: you can redistribute it and/or modify
42 *   it under the terms of the GNU General Public License as published by
43 *   the Free Software Foundation, either version 3 of the License, or
44 *   (at your option) any later version.<BR>
45 * <BR>
46 *   RefereeToolbox is distributed in the hope that it will be useful,
47 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
48 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
49 *   GNU General Public License for more details.<BR>
50 * <BR>
51 *   You should have received a copy of the GNU General Public License
52 *   along with RefereeToolbox. If not, see
54 * </font></table><BR>
55 *
56 */
57public class BBACommon <Prop extends Lattice<Prop>,
58                                            B extends BBACommon<Prop,B> >
59                                            implements BasicBeliefAssignment<Prop,B> {
60
61
62    //////////////////////////////////////////////////:
63    // public part
64    ///////////////
65
66    /**
67     * This method is not defined for class {@link BBACommon } and generates an error
68     * report and a code exit.
69     * <BR><BR>
70     * <b>Documentation inherited from {@link BasicBeliefAssignment }:</b><BR>
71     * {@inheritDoc}
72     */
73    public B duplicate(B input) {
74        System.err.println("Error :: "+this.getClass().getName() +
75                ".duplicate(B) is not implemented!");
76        System.err.println("Please implement clone() in your class with @Override");
77        System.exit(0);
78        return null;
79    }
80
81    @Override
82    public B clone() {
83        return instance().duplicate((B) this);
84    }
85
86    /**
87     * This method is not defined for class {@link BBACommon } and generates an error
88     * report and a code exit.
89     * <BR><BR>
90     * <b>Documentation inherited from {@link BasicBeliefAssignment }:</b><BR>
91     * {@inheritDoc}
92     */
93    public B instance() {
94        System.err.println("Error :: "+this.getClass().getName() +
95                ".clone() is not implemented!");
96        System.err.println("Please implement clone() in your class with @Override");
97        System.exit(0);
98        return null;
99    }
100
101    /**
102     * This method is not defined for class {@link BBACommon } and produces the String
103     * {@code "UNDEFINED" }.
104     * <BR><BR>
105     * <b>Documentation inherited from {@link BasicBeliefAssignment }:</b><BR>
106     * {@inheritDoc}
107     */
108    public String state(int choix) {
109        return "UNDEFINED";
110    }
111
112    /**
113     * This method is not defined for class {@link BBACommon } and generates an error
114     * report and a code exit.
115     * <BR><BR>
116     * <b>Documentation inherited from {@link BasicBeliefAssignment }:</b><BR>
117     * {@inheritDoc}
118     */
119    public ArrayList<Assignment<Prop>> toArray() {
120        System.err.println("Error :: "+this.getClass().getName() +
121                ".toArray() is not implemented!");
122        System.err.println("Please implement toArray() in your class with @Override");
123        System.exit(0);
124        return null;
125    }
126
127    public boolean load(Collection<Assignment<Prop>> anAssignmentTab) {
128        clear();
129        addAll(anAssignmentTab);
130        return true;
131    }
132
133    /**
134     * This method is not defined for class {@link BBACommon } and generates an error
135     * report and a code exit.
136     * <BR><BR>
137     * <b>Documentation inherited from {@link BasicBeliefAssignment }:</b><BR>
138     * {@inheritDoc}
139     */
140    public void clear() {
141        System.err.println("Error :: "+this.getClass().getName() +
142                ".clear() is not implemented!");
143        System.err.println("Please implement clear() in your class with @Override");
144        System.exit(0);
145    }
146
147    /**
148     * This method is not defined for class {@link BBACommon } and generates an error
149     * report and a code exit.
150     * <BR><BR>
151     * <b>Documentation inherited from {@link BasicBeliefAssignment }:</b><BR>
152     * {@inheritDoc}
153     */
154    public boolean add(Prop aProposition, double anAssignmentValue) {
155        System.err.println("Error :: "+this.getClass().getName() +
156                ".add() is not implemented!");
157        System.err.println("Please implement add() in your class with @Override");
158        System.exit(0);
159        return true;
160    }
161
162    public boolean add(Assignment<Prop> anAssignment) {
163        return add(anAssignment.attribute,anAssignment.value);
164    }
165
166    public boolean addAll(Collection<Assignment<Prop>> assignTab) {
167        //bbaTree;
168        boolean test=true;
169        for (Iterator<Assignment<Prop>> it = assignTab.iterator();
170                                            it.hasNext(); ) {
171            test=test&&add(it.next());
172       }
173        return test;
174    }
175
176    /**
177     * This method is not defined for class {@link BBACommon } and generates an error
178     * report and a code exit.
179     * <BR><BR>
180     * <b>Documentation inherited from {@link BasicBeliefAssignment }:</b><BR>
181     * {@inheritDoc}
182     */
183    public Assignment<Prop> findProposition(Assignment<Prop> anAssignment) {
184        System.err.println("Error :: "+this.getClass().getName() +
185                ".findProposition(Assignment<Prop>) is not implemented!");
186        System.err.println("Please implement findProposition(Assignment<Prop>)" +
187                " in your class with @Override");
188        System.exit(0);
189        return null;
190    }
191
192    public Assignment<Prop> findProposition(Prop aProposition) {
193        Assignment<Prop> searchAssign = new Assignment<Prop>();
194        searchAssign.attribute=aProposition;
195        return findProposition(searchAssign);
196    }
197
198    public double m(Prop aProposition) {
199
200        Assignment<Prop>  foundPair=findProposition(aProposition);
201        if(foundPair!=null) {
202                return foundPair.value;
203            }
204        return 0.;
205    }
206
207    /**
208     * This method is not defined for class {@link BBACommon } and generates an error
209     * report and a code exit.
210     * <BR><BR>
211     * <b>Documentation inherited from {@link BasicBeliefAssignment }:</b><BR>
212     * {@inheritDoc}
213     */
214    public double Bel(Prop aProposition) {
215        System.err.println("Error :: "+this.getClass().getName() +
216                ".Bel(Prop) is not implemented!");
217        System.err.println("Please implement Bel(Prop) in your class with @Override");
218        System.exit(0);
219        return -1;
220    }
221
222    /**
223     * This method is not defined for class {@link BBACommon } and generates an error
224     * report and a code exit.
225     * <BR><BR>
226     * <b>Documentation inherited from {@link BasicBeliefAssignment }:</b><BR>
227     * {@inheritDoc}
228     */
229    public double Pl(Prop aProposition) {
230        System.err.println("Error :: "+this.getClass().getName() +
231                ".Pl(Prop) is not implemented!");
232        System.err.println("Please implement Pl(Prop) in your class with @Override");
233        System.exit(0);
234        return -1;
235    }
236
237    /**
238     * This method is not defined for class {@link BBACommon } and generates an error
239     * report and a code exit.
240     * <BR><BR>
241     * <b>Documentation inherited from {@link BasicBeliefAssignment }:</b><BR>
242     * {@inheritDoc}
243     */
244    public double remove(Prop aProposition) {
245        System.err.println("Error :: "+this.getClass().getName() +
246                ".remove(Prop) is not implemented!");
247        System.err.println("Please implement remove(Prop) in your class with @Override");
248        System.exit(0);
249        return -1.;
250    }
251
252    /**
253     * This method is not defined for class {@link BBACommon } and generates an error
254     * report and a code exit.
255     * <BR><BR>
256     * <b>Documentation inherited from {@link BasicBeliefAssignment }:</b><BR>
257     * {@inheritDoc}
258     */
259    public B mix(ArrayList<B> bbaIn, double[] weight) {
260        System.err.println("Error :: "+this.getClass().getName() +
261                ".mix(ArrayList<B>, double[]) is not implemented!");
262        System.err.println("Please implement mix(ArrayList<B>, double[]) in your" +
263                " class with @Override");
264        System.exit(0);
265        return null;
266    }
267
268    public void update_notification() { // called each time a change is done
269    }
270
271}
Source Code: BBACommon.java
1/*
2 *   BBAFuser.java : part of package RefereeToolbox; Interface for the fusion of
3 *          Basic Belief Assigments.
4 *******************************************************************************
5 *   Copyright (c) 2010 Frédéric Dambreville
6 *
7 *   Author:    Frédéric Dambreville <http://email.fredericdambreville.com>
8 *
9 *   This file is part of RefereeToolbox.
10 *
11 *   RefereeToolbox is free software: you can redistribute it and/or modify
12 *   it under the terms of the GNU General Public License as published by
13 *   the Free Software Foundation, either version 3 of the License, or
14 *   (at your option) any later version.
15 *
16 *   RefereeToolbox is distributed in the hope that it will be useful,
17 *   but WITHOUT ANY WARRANTY; without even