Algorithm for scaling two values (positive or negative) to between 0 and 1

I'm looking for an algorithm that will scale and consolidate two numbers:

func scale(x: Int, y: Int) -> Double { 
    // algorithm here
    return 0.5
}

The algorithm must satisfy the following constraints:

• Return values between 0 and 1
• If x and y are the same return 0.5
• If x is "bigger"* than y return some number > 0.5
• If y is "bigger"* than x return some number < 0.5
• Return values are relative, so scale(x: -5, y: 4) < scale(x: -5, y: 0) == True
• * -1 is "bigger" than -2

Here's the test suite (for use in a Swift Playground):

import Foundation
import XCTest

func XCTAssertBetween(_ value: Double, _ range: ClosedRange<Double>, _ message: @autoclosure () -> String = "", file: StaticString = #file, line: UInt = #line) {
    XCTAssertGreaterThanOrEqual(value, range.lowerBound, "Value is less than lower bound", file: file, line: line)
    XCTAssertLessThanOrEqual(value, range.upperBound, "Value is more than upper bound", file: file, line: line)
}

class ScaleTests: XCTestCase {
    func testZZ() {
        XCTAssertEqual(scale(x: 0, y: 0), 0.5)
    }
    
    func testPP() {
        XCTAssertEqual(scale(x: 1, y: 1), 0.5)
    }
    
    func testPZ() {
        XCTAssertBetween(scale(x: 1, y: 0), 0.51...1)
    }
    
    func testZP() {
        XCTAssertBetween(scale(x: 0, y: 1), 0...0.49)
    }
    
    func testNN() {
        XCTAssertEqual(scale(x: -1, y: -1), 0.5)
    }
    
    func testZN() {
        XCTAssertBetween(scale(x: 0, y: -1), 0.51...1)
    }
    
    func testNZ() {
        XCTAssertBetween(scale(x: -1, y: 0), 0...0.49)
    }
}
  
ScaleTests.defaultTestSuite.run()

What you're describing is a sigmoid function, and any properly scaled sigmoid will do this. Starting with your difference:

let d = Double(x) - Double(y)

Some example scaled Sigmoids:

return 1 / (1 + exp(-d)) // Logistic function as emehex demonstrated

return atan(d) / .pi + 0.5

return tanh(d) / 2 + 0.5 // Another form of the logistic

return 0.5 + d / (2*sqrt(1 + d * d))

The logistic function is the traditional one to use in this case, but you may want others for performance or other characteristics.

As @emehex notes, the logistic function may bunch up the values more than you like within your scale. You can fix that by rescaling d, multiplying or dividing it by whatever you like to get the "steepness" you want.

Depending on how much you're using this, you may want to look at one of the several sigmoid functions available in the Apple ecosystem. This function is extremely common in machine learning applications.

This is close (it satisfies all of the tests):

func scale(x: Int, y: Int) -> Double {
    let val = Double(x - y)
    return 1 / (1 + exp(-val))
}

But I don't love that all of these are ~= 0.99:

scale(x: 5, y: 0) // wish this was 0.8-ish
scale(x: 10, y: 0) // 0.90-ish
scale(x: 20, y: -10) // 0.99-ish