Set of real numbers: Difference between revisions

 

'''Implementation notes'''

* Infinities should be handled gracefully; indeterminate numbers (NaN) can be ignored.

* You can use your machine's native real number representation, which is probably IEEE floating point, and assume it's good enough (it usually is).

* Define ''[http://www.wolframalpha.com/input/?i=%7Csin%28pi+x2%29%7C%3E1%2F2%2C+0+%3C+x+%3C+10 A]'' = {''x'' | 0 < ''x'' < 10 and |sin(π ''x''²)| > 1/2 }, ''[http://www.wolframalpha.com/input/?i=%7Csin%28pi+x%29%7C%3E1%2F2%2C+0+%3C+x+%3C+10 B]'' = {''x'' | 0 < ''x'' < 10 and |sin(π ''x'')| > 1/2}, calculate the length of the real axis covered by the set ''A'' − ''B''. Note that

|sin(π ''x'')| > 1/2 is the same as ''n'' + 1/6 < ''x'' < ''n'' + 5/6 for all integers ''n''; your program does not need to derive this by itself.

 

=={{header|C sharp}}==

 

namespace RosettaCode.SetOfRealNumbers

}

}

Test:

using RosettaCode.SetOfRealNumbers;

 

}

}

 

=={{header|Clojure}}==

{{trans|Racket}}

 

(defn >=|<= [lo hi] #(<= lo % hi))

(def Q ratio?)

(def I #(∖ R Z Q))

 

=={{header|Common Lisp}}==

Common Lisp has a standard way to represent intervals.

(deftype set<> (a b) `(real (,a) (,b)))

(deftype set=> (a b) `(real ,a (,b)))

(assert (not (in-set-p 0 set)))

(assert (not (in-set-p 1 set)))

 

=={{header|D}}==

{{trans|C sharp}}

const pure nothrow bool delegate(in T) contains;

 

}

 

 

=={{header|EchoLisp}}==

Implementation of sets operations, which apply to '''any''' subsets of ℜ defined by a predicate.

===Sets operations===

(lib 'match) ;; reader-infix macros

 

(define (⟧...⟧ a b)(lambda(x) (and (> x a) (<= x b))))

(define (⟧...⟦ a b)(lambda(x) (and (> x a) (< x b))))

{{out}}

<pre>

</pre>

=== Optional : measuring sets===

;; The following applies to convex sets ⟧...⟦ Cx,

;; and families F of disjoint convex sets.

→ 2.075864841184666

 

 

=={{header|Elena}}==

extension setOp

{

}

// union

// intersection

// difference

 

=={{header|F#|F sharp}}==

 

let union s1 s2 =

assert (not (i1 2.0))

 

 

=={{header|Go}}==

Just the non-optional part:

 

import "fmt"

fmt.Println()

}

[http://play.golang.org/p/YQ2GRBM4af Run in Go Playground].

{{out}}

2 ∈ s3: true</pre>

This simple implementation doesn't support lengths so the although the A, B, and A−B sets can be defined and tested (see below), they can't be used to implement the optional part.

return math.Abs(math.Sin(math.Pi*x*x)) > .5

})

for x := float64(5.98); x < 6.025; x += 0.01 {

fmt.Printf("%.2f ∈ A−B: %t\n", x, C(x))

 

==Icon and {{header|Unicon}}==

simplifications of some representations, but more could be done.

 

s1 := RealSet("(0,1]").union(RealSet("[0,2)"))

s2 := RealSet("[0,2)").intersect(RealSet("(1,2)"))

initially(s)

put(ranges := [],Range(\s).notEmpty())

 

Sample run:

In essence, this looks like building a restricted set of statements. So we build a specialized parser and expression builder:

 

ing=: `''

union=: 4 :'(x has +. y has)ing'

intersect=: 4 :'(x has *. y has)ing'

 

With this in place, the required examples look like this:

 

1 1 0

('[0,2)' intersect '(1,2]')has 0 1 2

1 1 1

('[0,3)' without '[0,1]')has 0 1 2

 

Note that without the arguments these wind up being expressions. For example:

 

 

In other words, this is a statement built up from inequality terminals (where each inequality is bound to a constant) and the terminals are combined with logical operations.

Here is an alternate formulation which allows detection of empty sets:

 

ing=: `''

 

without=: 4 :'(x has *. [: -. y has)ing; x edges y'

in=: 4 :'y has x'

 

The above examples work identically with this version, but also:

 

0

isEmpty '[0,2)' intersect '(1,2]'

1

isEmpty '[0,2]' intersect '[2,3]'

 

Note that the the set operations no longer return a simple verb -- instead, they return a pair, where the first element represents the verb and the second element is a list of interval boundaries. We can tell if two adjacent bounds, from this list, bound a valid interval by checking any point between them.

The optional work centers around expressions where the absolute value of sin pi * n is 0.5. It would be nice if J had an arcsine which gave all values within a range, but it does not have that. So:

 

 

(Note on notation: 1 o. is sine in J, and 2 o. is cosine -- the mnemonic is that sine is an odd function and cosine is an even function, the practical value is that sine, cosine and sine/cosine pairs can all be generated from the same "real" valued function.

Similarly, _1 o. is arcsine and _2 o. is arcsine. Also 1p_1 is the reciprocal of pi. So the above tells us that the principal value for arc sine 0.5 is one sixth.)

 

1 5 7 11 13 17 19 23 25 29

2 -~/\ (#~ 0.5 = 1 |@o. 1r6p1&*) i. 30

 

Here we see the integers which when multiplied by pi/6 give 0.5 for the absolute value of the sine, and their first difference. Thus:

 

 

is a function to generate the values which correspond to the boundaries of the intervals we want:

 

zA=: zeros0toN&.*: 10

 

200

#zB

 

And, here are the edges of the sets of intervals we need to consider.

To find the length of the the set A-B we can find the length of set A and subtract the length of the set A-B:

 

 

Here, we have paired adjacent elements from the zero bounding list (non-overlapping infixes of length 2). For set A's length we sum the results of subtracting the smaller number of the pair from the larger. For set A-B's length we consider each combination of pairs from A and B and subtract the larger of the beginning values from the smaller of the ending values (and ignore any negative results).

Alternatively, if we use the set implementation with empty set detection, and the following definitions:

 

A=: union/_2 intervalSet/\ zA

B=: union/_2 intervalSet/\ zB

 

We can replace the above sentence to compute the length of the difference with:

 

 

(Note that this result is not exactly the same as the previous result. Determining why would be an interesting exercise in numerical analysis.)

 

=={{header|Java}}==

import java.util.function.Predicate;

 

System.out.printf("Approx length of A - B is %f\n", cc.length());

}

{{out}}

<pre>(0, 1] ∪ [0, 2) contains 0 is true

 

Approx length of A - B is 2.075870</pre>

 

=={{header|Julia}}==

"""

struct ConvexRealSet

 

testconvexrealset()

{{output}}<pre>

Testing with x = 0.

 

Clearly, the above approach is only suitable for sets with narrow ranges (as we have here) but does have the merit of not over-complicating the basic class.

 

typealias RealPredicate = (Double) -> Boolean

val cc = aa subtract bb

println("Approx length of A - B is ${cc.length}")

 

{{out}}

</pre>

 

setcc[a_, b_] := a <= x <= b

setoo[a_, b_] := a < x < b

Print[set4]

Print["Fourth trial set, [0,3)\[Minus][0,1], testing for {0,1,2}:"]

{{Output}}

<pre>0<x<=1||0<=x<2

{False,False,True}</pre>

 

 

=={{header|PARI/GP}}==

Define some sets and use built-in functions:

set01(x,a,b)=select(x -> a < x && x <= b, x);

set10(x,a,b)=select(x -> a <= x && x < b, x);

setintersect(set10(V, 0, 2), set01(V, 1, 2))

setminus(set10(V, 0, 3), set00(V, 0, 1))

Output:<pre>

[0, 1, 2]

[2]</pre>

=={{header|Perl}}==

 

# numbers used as boundaries to real sets. Each has 3 components:

my $z = $x - $y;

print "A - B\t= ", brev($z), "\n\tlength = ", $z->len, "\n";

Set 1 = (0.00, 2.00): has 1;

Set 2 = [0.00, 0.00] ∪ [1.00, 3.00): has 0; has 1; has 2;

A - B = [0.83, 0.91) ∪ (1.08, 1.17] ∪ ... ∪ (9.91, 9.94) ∪ (9.96, 9.99)

length = 2.07586484118467

 

{{works with|Rakudo|2018.10}}

has $.range handles <min max excludes-min excludes-max minmax ACCEPTS>;

method empty {

say "A − B =";

say " ",.gist for $C.intervals;

{{out}}

<pre> 0 1 2

(9.9582461641931,9.99166319154791)

Length A − B = 2.07586484118467</pre>

 

=={{header|REXX}}==

===no error checking, no ∞===

call quertySet 1, 3, '[1,2)'

call quertySet , , '[0,2) union (1,3)'

parse var q @.1 2 @.2 ',' @.3 (@.4)

if @.2>@.3 then parse var L . @.0 @.2 @.3

{{out|output|text=&nbsp; is the same as the next REXX version (below).}}

 

===has error checking, ∞ support===

call quertySet 1, 3, '[1,2)'

call quertySet , , '[0,2) union (1,3)'

end /*j*/

if @.2>@.3 then parse var L . @.0 @.2 @.3

{{out|output|text=&nbsp; when using the (internal) default inputs:}}

<pre>

=={{header|Ruby}}==

{{works with|Ruby|1.9.3}}

Set = Struct.new(:lo, :hi, :inc_lo, :inc_hi) do

def include?(x)

def Rset(lo, hi, inc_hi=false)

Rset.new(lo, hi, false, inc_hi)

 

Test case:

[1,2,3].each{|x|puts "#{x} => #{a.include?(x)}"}

puts

puts "a = #{a = Rset(-inf,inf)}"

puts "b = #{b = Rset.parse('[1/3,11/7)')}"

 

{{out}}

{{works with|Ruby|2.1+}}

(with Rational suffix.)

puts "#{str} -> #{eval(str)}\t\t# create empty set"

str = "e.empty?"

puts "b.length : #{b.length}"

puts "a - b : #{a - b}"

 

{{out}}

(a-b).length : 2.0758648411846745

</pre>

 

=={{header|Tcl}}==

This code represents each set of real numbers as a collection of ranges, where each range is quad of the two boundary values and whether each of those boundaries is a closed boundary. (Using expressions internally would make the code much shorter, at the cost of being much less tractable when it comes to deriving information like the length of the real line “covered” by the set.) A side-effect of the representation is that the length of the list that represents the set is, after normalization, the number of discrete ranges in the set.

 

proc inRange {x range} {

}

return $len

Basic problems:

{(0, 1] ∪ [0, 2)} {

union [realset {(0,1]}] [realset {[0,2)}]

puts "$x : $str :\t[elementOf $x $Set]"

}

Extra credit:

for {set i $from} {$i<=$to} {incr i} {

lappend result [list [expr {$i+1./6}] 0 [expr {$i+5./6}] 0]

set B [spi2 0 10]

set AB [difference $A $B]

Output:

<pre>

2 : [0, 3) − [0, 1] : 1

40 contiguous subsets, total length 2.075864841184667

</pre>

 

{{trans|D}}

No ∞

fcn init(fx){ var [const] contains=fx; }

fcn holds(x){ contains(x) }

fcn __opSub(rs){ RealSet('wrap(x){ contains(x) and not rs.contains(x) }) }

fcn intersection(rs) { RealSet('wrap(x){ contains(x) and rs.contains(x) }) }

The python method could used but the zkl compiler is slow when used in code to generate code.

 

The method used is a bit inefficient because it closes the contains function of the other set so you can build quite a long call chain as you create new sets.

 

// test union

tester.testRun(s.holds(0.0),Void,False,__LINE__);

tester.testRun(s.holds(1.0),Void,False,__LINE__);

{{out}}

<pre>

</pre>

 

{{omit from|Lilypond}}

{{omit from|TPP}}