Styjun

I currently receive a Int that could be anywhere between 0 and 180,000. I need to change it to fit between 0 and 3000. I know in other languages you can use something like

Map(min1,max1,min2,max2,input)

I can't seem to find something like that inside of swift.
This is what I currently have, but it always returns 0.

var newY = [(Int)(input)]
newY = newY.map _ in 0 * 3000
print(newY[0])

I think I am using the wrong function. I have never done any mapping in Swift before.

The map function on collections is going to do something very different. It applies a mapping function to each element of a collection and returns a new collection based on the results.

What you're looking for would be:

func map(minRange:Int, maxRange:Int, minDomain:Int, maxDomain:Int, value:Int) -> Int 
 return minDomain + (maxDomain - minDomain) * (value - minRange) / (maxRange - minRange)


print(map(minRange: 0, maxRange: 1800000, minDomain: 0, maxDomain: 3000, value: 200000))

With only a little more work you can make it generic over all integer types:

func map<T:IntegerArithmetic>(minRange:T, maxRange:T, minDomain:T, maxDomain:T, value:T) -> T 
 return minDomain + (maxDomain - minDomain) * (value - minRange) / (maxRange - minRange)

Another option would be to take advantage of the Swift Range type to make calling more succinct:

func map<T:IntegerArithmetic>(range:Range<T>, domain:Range<T>, value:T) -> T 
 return domain.lowerBound + (domain.upperBound - domain.lowerBound) * (value - range.lowerBound) / (range.upperBound - range.lowerBound)


map(range:0..<3000, domain:0..<180000, value: 1500)

It's not clear whether the OP simply wants to clamp (title seems to say that) or wants to interpolate from one bounding range to another. The title makes me think one, but the dual max/min values make me think they're after an interpolation. I answered the former. David Berry has a good answer for the latter.

What you may want is min/max functions. Swift has these. To "clamp" a value between a low and high value, you usually combine the two:

var bottom = 13
var top = 42
var tooLow = 7
var clamped = min(top, max(bottom, tooLow)) -> 13
var justRight = 23
clamped = min(top, max(bottom, justRight)) --> 23
var tooHigh = 99
clamped = min(top, max(bottom, tooHigh)) --> 42

This is usually the route most people go, and is probably good enough for most. I personally hate writing that again and again, and I get tired of having to think about which side to feed into the max and the min. And I don't like that it uses what looks like a free function, I'm an object oriented message sending sort of guy, so I do the following:

precedencegroup MinMaxPrecedence 
 associativity: left
 higherThan: NilCoalescingPrecedence, AdditionPrecedence, MultiplicationPrecedence


infix operator <> : MinMaxPrecedence

func <><T:Comparable>(a:T, b:T) -> T 
 return a < b ? a : b


infix operator >< : MinMaxPrecedence

func ><<T:Comparable>(a:T, b:T) -> T 
 return a < b ? b : a

Basically, this defines two new operators (<> and ><) that can be used between any type that adopts Comparable. They're easy for me to remember, the one that tucks in smaller wants the smaller value, and the one that opens up bigger returns the bigger value. What's nice is that you can then put them in simpler expressions:

var bottom = 13
var top = 42
var tooLow = 7
var justRight = 23
var tooHigh = 99
bottom >< tooLow <> top --> 13
bottom >< justRight <> top --> 23
bottom >< tooHigh <> top --> 42

Given that you are looking for mapping the relative position of a value in a given range to another range, you could do something along the lines:

// dummy function name
func transform(_ number: Int, fromRange: (Int, Int), toRange: (Int, Int)) -> Int? 
 guard number >= fromRange.0 && number <= fromRange.1,
 toRange.0 <= toRange.1 else return nil 
 return toRange.0 + (number-fromRange.0)*(toRange.1-toRange.0)/(fromRange.1-fromRange.0)


// ex1
let numberA = 3001
let transformedNumberA = transform(numberA, fromRange: (0, 180_000), toRange: (0,3000))
print(transformedNumberA ?? -1) // 50

// ex2
let numberB = 134_000
let transformedNumberB = transform(numberB, fromRange: (0, 180_000), toRange: (0,3000))
print(transformedNumberB ?? -1) // 2233

// ex3
let numberC = 200_000
let transformedNumberC = transform(numberC, fromRange: (0, 180_000), toRange: (0,3000))
print(transformedNumberC ?? -1) // -1 (nil return)

Just take care to notice that (number-fromRange.0)*(toRange.1-toRange.0) (left associativity of / and * operators) may overflow.

//Map function
func mapy(n:Double, start1:Double, stop1:Double, start2:Double, stop2:Double) -> Double 
 return ((n-start1)/(stop1-start1))*(stop2-start2)+start2;
;