regions.py

from collections import namedtuple

Point = namedtuple('Point', ['x', 'y'])

def circle(distance):
    return lambda point: (point.x ** 2. + point.y ** 2.) ** (1/2.) < distance

def offset(region, position):
    return lambda point: region(Point(x=point.x-position.x, y=point.y-position.y))

def inverse(region):
    return lambda point: not region(point)

def intersection(region1, region2):
    return lambda point: region1(point) and region2(point)

def diference(region1, region2):
    return intersection(region1, inverse(region2))


def target(max_distance, min_distance, friend):
    donnut_region = diference(circle(max_distance), circle(min_distance))
    friend_region = offset(circle(min_distance), friend)
    return diference(donnut_region, friend_region)

region = target(3, 1, Point(2,2))

print region(Point(x=1,y=1))

regions.rb

Point = Struct.new(:x, :y)

def Point(hash)
  Point.new(hash[:x], hash[:y])
end

def Region(&block)
  block.tap{|b|b.instance_eval{alias :include? :call}}
end

def circle(distance)
  Region{|point| (point.x ** 2.0 + point.y ** 2.0) ** (1/2.0) < distance}
end

def offset(region, position)
  Region{|point| region.include? Point(x: point.x - position.x, y: point.y - position.y)}  
end

def inverse(region)
  Region{|point| !region.include? point}
end

def intersection(region1, region2)
  Region{|point| region1.include?(point) && region2.include?(point)}
end

def diference(region1, region2)
  intersection(region1, inverse(region2))
end

def target(max_distance, min_distance, friend)
    donnut_region = diference(circle(max_distance), circle(min_distance))
    friend_region = offset(circle(min_distance), friend)
    diference(donnut_region, friend_region)
end


region = target(3, 1, Point(x:2,y:2))

puts region.include?(Point(x:1,y:1))

regions.swift

import CoreGraphics

typealias Position = CGPoint
typealias Distance = CGFloat

let minimumDistance : Distance = 2.0

func inRange(target: Position, ownPosition: Position, friendly: Position, range: Distance) -> Bool {
    let dx = ownPosition.x - target.x
    let dy = ownPosition.y - target.y
    let friendlyDx = friendly.x - target.x
    let friendlyDy = friendly.y - target.y
    return sqrt(dx * dx + dy * dy) <= range && sqrt(dx * dx + dy * dy) >= minimumDistance && (sqrt(friendlyDx * friendlyDx + friendlyDy * friendlyDy) >= minimumDistance)
}

inRange(Position(x: 4.0, y:4.0), Position(x:0.0, y:0.0), Position(x:50.0, y:50.0), 10.0)

typealias Region = Position -> Bool

func circle(radius: Distance) -> Region {
    return { point in sqrt(point.x * point.x + point.y * point.y) <= radius }
}

circle(3.0)(Position(x:1.0, y:1.0))

func shift(offset: Position, region: Region) -> Region {
    return { point in
        let shiftedPoint = Position(x: point.x + offset.x, y: point.y + offset.y)
        return region(shiftedPoint)}
}

func intersection(region1 : Region, region2 : Region) -> Region {
    return { point in region1(point) && region2(point) }
}

func invert(region: Region) -> Region {
    return { point in !region(point) }
}


func difference(region: Region, minusRegion: Region) -> Region {
    return intersection(region, invert(minusRegion))
}

func inRangeF(ownPosition: Position, target: Position, friendly: Position, range: Distance) -> Bool {
    let targetRegion = shift(ownPosition, difference(circle(range), circle(minimumDistance)))
    let friendlyRegion = shift(friendly, circle(minimumDistance))
    let resultRegion = difference(targetRegion, friendlyRegion)
    return resultRegion(target)
}

inRangeF(Position(x: 4.0, y:4.0), Position(x:0.0, y:0.0), Position(x:50.0, y:50.0), 10.0)