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).

=={{header|C}}==

Providing an implementation of lambdas would be better, but this should do for now.

#include <stdbool.h>

#include <stdio.h>

 

return 0;

{{out}}

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

 

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

 

namespace RosettaCode.SetOfRealNumbers

}

}

Test:

using RosettaCode.SetOfRealNumbers;

 

}

}

 

=={{header|C++}}==

{{trans|Java}}

#include <functional>

#include <iostream>

 

return 0;

{{out}}

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

=={{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|Delphi}}==

{{libheader| System.SysUtils}}

{{Trans|Go}}

program Set_of_real_numbers;

 

end;

readln;

 

=={{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

set(0.0r).assertTrue();

// intersection

set2(0.0r).assertFalse();

// difference

set3(0.0r).assertFalse();

set3(1.0r).assertFalse();

set3(2.0r).assertTrue();

 

=={{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))

 

=={{header|Haskell}}==

{- Not so functional representation of R sets (with IEEE Double), in a strange way -}

 

mapM_ isintest restest >>

putStrLn ("measure: " ++ (show (set_measure (set_difference testA testB))))

{{out}}

<pre>

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

 

=={{header|Javascript}}==

function realSet(set1, set2, op, values) {

const makeSet=(set0)=>{

return res;

}

 

=={{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}}

 

=={{header|Lua}}==

local l,h = tonumber(low), tonumber(high)

if l and h then

)

local cc = aa.subtract(bb)

{{out}}

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

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

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

=={{header|Nim}}==

{{trans|Kotlin}}

 

type

cc = aa - bb

 

 

{{out}}

=={{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>

 

=={{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

 

=={{header|Phix}}==

{{trans|Go}}

{{out}}

<pre>

</pre>

Extra credit - also translated from Go, but with an extended loop and crude summation, inspired by Java/Kotlin.

{{out}}

<pre>

 

=={{header|Python}}==

def __init__(self, lo, hi, includelo=True, includehi=False):

self.eqn = "(%i<%sX<%s%i)" % (lo,

% ('in' if v in s else 'ex', v)

for v in range(3)),

 

;Output:

=={{header|Racket}}==

This is a simple representation of sets as functions (so obviously no good way to the the extra set length).

#lang racket

 

(try ((0 +-- 3) ∖ (0 --- 1)))

(try ((0 +-- 3) ∖ (0 +-+ 1)))

 

Output:

(formerly Perl 6)

{{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

=={{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 <code>CompositeSet</code> which represents a <code>SetOperation</code> (union, intersection, or difference) between two other <code>RealSet</code>s, which themselves can be composite or not. When the <code>contains()</code> method is called on a composite set for a given number, it will recursively call contains() on its component sets to check whether they contain the number. Depending on the operation, this will define whether the number is contained in this set.

Since we use Rust's [https://doc.rust-lang.org/std/primitive.f64.html f64], which is a standard [https://en.wikipedia.org/wiki/IEEE_754 IEEE 754] double-precision floating-point number, we get correct behavior at infinity for free.

enum SetOperation {

Union,

}

}

<pre>Set (0, 1] ∪ [0, 2)

- contains 0

=={{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>

{{trans|Kotlin}}

{{libheader|Wren-dynamic}}

 

var RangeType = Enum.create("RangeType", ["CLOSED", "BOTH_OPEN", "LEFT_OPEN", "RIGHT_OPEN"])

var bb = RealSet.new(0, 10) { |x| (0 < x && x < 10) && ((Num.pi * x).sin.abs > 0.5) }

var cc = aa.subtract(bb)

 

{{out}}

{{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>