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)
Here's a version that works for both Double and Float:
extension FloatingPoint {
/// Allows mapping between reverse ranges, which are illegal to construct (e.g. `10..<0`).
func interpolated(
fromLowerBound: Self,
fromUpperBound: Self,
toLowerBound: Self,
toUpperBound: Self) -> Self
{
let positionInRange = (self - fromLowerBound) / (fromUpperBound - fromLowerBound)
return (positionInRange * (toUpperBound - toLowerBound)) + toLowerBound
}
func interpolated(from: ClosedRange<Self>, to: ClosedRange<Self>) -> Self {
interpolated(
fromLowerBound: from.lowerBound,
fromUpperBound: from.upperBound,
toLowerBound: to.lowerBound,
toUpperBound: to.upperBound)
}
}
Usage:
50.interpolated(from: 0...100, to: 0...10) == 5
3.interpolated(from: 1...5, to: 0...10) == 5
4.interpolated(from: 1...5, to: 1...10) == 7.75
11.interpolated(
fromLowerBound: 10,
fromUpperBound: 20,
toLowerBound: 100,
toUpperBound: 120) == 102
11.interpolated(
fromLowerBound: 10,
fromUpperBound: 20,
toLowerBound: 120,
toUpperBound: 100) == 118
11.interpolated(
fromLowerBound: 20,
fromUpperBound: 10,
toLowerBound: 100,
toUpperBound: 120) == 118
11.interpolated(
fromLowerBound: 20,
fromUpperBound: 10,
toLowerBound: 120,
toUpperBound: 100) == 102
//Map function
func mapy(n:Double, start1:Double, stop1:Double, start2:Double, stop2:Double) -> Double {
return ((n-start1)/(stop1-start1))*(stop2-start2)+start2;
};
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.
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
Or you can use the simd_mix function...
import simd
func remap(sourceMin: Float, sourceMax: Float, destMin: Float, destMax: Float, t: Float) -> Float {
let f = (t - sourceMin) / (sourceMax - sourceMin)
return simd_mix(destMin, destMax, f)
}
