[racket] fuzzy set representation in Racket

Thank you, this is amazing! I am a Racketeer for life.


On Mon, Aug 26, 2013 at 10:02 PM, Matthias Felleisen
<matthias at ccs.neu.edu>wrote:

>
> Just add fuzzy-set? to the provide specification of fuzzy-set-library.
>  Also add other functions as needed and provide them.
>
>
>
> On Aug 26, 2013, at 9:09 PM, Rian Shams wrote:
>
> Thank you, a fuzzy-set-library is exactly what I am looking for. Initially
> I tried to create this library using the methodology you describe from the
> chapter on sets in "The Little Schemer," but after discovering structs in
> Racket I switched over. More recently I have been trying to emulate the
> set.rkt file that is provided in collect, but am finding this overwhelming
> (at least for the time being).
>
> In order to define the fuzzy set operators I believe I would need
> fuzzy-set? and then selectors that correspond to each field. I am unclear
> as to why fuzzy-set? doesn't seem to exist and am not sure how to create
> fuzzy-set-first and fuzzy-set-rest (along with all of the other operators
> such as fuzzy-union, fuzzy-intersect , etc...) without having a fuzzy-set?
> made available.
>
> My question is given:
>
> (fuzzy-set
>   (fuzzy-element 'a 1)
>   (fuzzy-element 'b .2)
>   (fuzzy-element 'c .2)
>   (fuzzy-element 'd .3)))
>
> in the way you defined fuzzy-set above, how do you create the function
> fuzzy-set? and how do you create fuzzy-first and fuzzy-rest ?
>
> Thanks,
> Rian
>
> On Aug 23, 2013, at 8:02 PM, Matthias Felleisen <matthias at ccs.neu.edu>
> wrote:
>
>
> Here is one more alternative:
>
> #lang racket
>
> ;; you can move the body of this module into a '#lang racket' file called
> fuzzy-set-library.rkt
> (module fuzzy-set-library racket
>   ;; rename-out is an elegant version of the let()/define-values trick in
> Realm of Racket
>   (provide (rename-out (fuzzy-set0 fuzzy-set)) (struct-out fuzzy-element))
>
>   (struct fuzzy-element (val degree) #:transparent)
>   ;; FE = (fuzzy-element Any [0,1))
>
>   (struct fuzzy-set (vals)
>     #:transparent
>     #:guard
>     ;; [List-of FE] -> Fuzzy-set
>     (lambda (le type-name)
>       (define-values (members _)
>         (for/fold ((s '()) (keys '())) ((x le))
>           (unless (fuzzy-element? x)
>             (error type-name "fuzzy-element expected, given: ~e" x))
>           (define k (fuzzy-element-val x))
>           (if (member k keys)
>               (values s keys)
>               (values (cons x s) (cons k keys)))))
>       (apply set members)))
>   ;; FuzzySet = (fuzzy-set [Set-of FE])
>
>   (define (fuzzy-set0 . x) ;; <--- this means take as many arguments as
> there are, as a list
>     (fuzzy-set x))
>
>   ;; add
>   ;; -- fuzzy-add-element
>   ;; -- fuzzy-union
>   ;; etc.
>   )
>
> ;; this could be a '#lang racket' file too
> (module fuzzy-set-client racket
>   ;; then you replace this with the usual require
>   (require (submod ".." fuzzy-set-library))
>
>   (fuzzy-set
>    (fuzzy-element 'a .1)
>    (fuzzy-element 'b .2)
>    (fuzzy-element 'c .3)
>    (fuzzy-element 'a .3)))
>
> ;; drop this, it exists to test
> (require 'fuzzy-set-client)
>
>
>
> On Aug 23, 2013, at 3:49 PM, Rian Shams wrote:
>
> Hello All,
>
> My name is Rian and I am a new Racket user and a novice programmer (Racket
> is my first language). First let me say that I am very grateful for the
> resources available online and the books, HTDP and Realm of Racket. I find
> your teaching methods very clear and as a result I am picking up Racket
> faster than I originally thought.
>
> I am a System Science graduate student whose primary research focus is on
> Fuzzy Set Theory. A fuzzy set is a collection of distinct elements where
> each element has a degree of membership associated with it.
>
> The representation I am currently using for a fuzzy set is the following:
> First I create a struct called fuzzy-element which consists of 2 fields;
> the first is the name of the element and the second is the elements degree
> of membership to the set which ranges from 0 to 1.
>
> ;; Data Definition
>
> #lang racket
>
> (struct fuzzy-element (member degree-of-membership)
>   #:transparent
>   #:guard (lambda (member degree-of-membership type-name)
>             (cond
>               [(not (and (number? degree-of-membership)
>                          (<= 0 degree-of-membership 1)
> degree-of-membership))
>                (error type-name
>                       "~e is not a number between 0 and 1"
>                       degree-of-membership)]
>               [else (values member degree-of-membership)])))
>
> ;; fuzzy-element is (fuzzy-element Symbol Number[0, 1])
> ;; interp. a fuzzy-element as a struct in which:
> ;;         -the first field is the member's name
> ;;         -the second field is the respective members degree of membership
>
> Then I combine them with a list so what I have now is a list of fuzzy
> elements.
>
> ;; ListOfFuzzyElement is one of:
> ;; - empty
> ;; - (cons fuzzy-element ListOfFuzzyElement)
>
> The problem with this data definition is that it allows for duplicate
> structs with the same field-1 elements.
>
> What I am looking to create is
>
> ;; A Fuzzy-Set is one of:
> ;; - empty list
> ;; - (cons *distinct* fuzzy-element ListOfFuzzyElement)
>
>
>
> Ideally the type of representation I would like to use should look like:
>
> (fuzzy-set (fuzzy-element 'a .1)
>                (fuzzy-element 'b .2)
>                (fuzzy-element 'c .3)
>                (fuzzy-element 'a .3))
>
> -> (fuzzy-set (fuzzy-element 'a .1)
>                    (fuzzy-element 'b .2)
>                    (fuzzy-element 'c .3))
>
> Upon evaluation, the last element, (fuzzy-element 'a .3) is deleted
> because there already exists a member named 'a (fuzzy-element 'a .1). It
> should work exactly like the built in "set" data type, except in this case
> it is a set of structures that checks the first fields of all structures
> and eliminates latter duplicates.
>
> Any guidance on how to create fuzzy-set representation this way or if you
> can suggest more concise and elegant methods I would be greatly
> appreciative.
>
> Thanks,
> --
> Rian Shams
> ____________________
>  Racket Users list:
>  http://lists.racket-lang.org/users
>
>
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.racket-lang.org/users/archive/attachments/20130826/54b3f9ae/attachment.html>