Skip to content

Quantitative Scales

zziuni edited this page May 5, 2013 · 46 revisions

WikiAPI ReferenceScalesQuantitative Scales

(역자주) Scale은 값이 일정하게 커지고 작아지게 하는 비율인 '축척'을 의미한다. 객체는 'scale', 의미설명은 '스케일'을 사용했다. 되도록.

Scale은 입력값의 정의역과 출력값의 치역를 매핑하는 함수다. **정량적 축척(Quantitative Scales)**은 입력값인 정의역이 실제 수치값이나 날짜 집합 처럼 연속된 값이고 **순서 척도(Ordinal Scale)**은 입력 정의역이 이름이나 분류명 같은 분리된 값이다. 스케일은 D3에서 필수 사용 요소는 아니며 선호하는 자신만의 수식이 있다면 사용하지 않아도 된다. 하지만, 스케일을 사용하면 데이터의 크기를 시각적인 표현으로 매핑하는 코드를 놀랍도록 간단하게 만들 수 있다.

d3.scale.linear는 scale 객체를 반환하는데, 이런 scale 객체는 객체이면서 함수이다. 함수이므로 일반 함수처럼 scale를 호출 할 수 있고 객체이기도 해서 스케일을 변경하는 확장 메서드가 있다. D3의 다른 클래스들 처럼 scale은 세터(setter) 메서드가 자기 자신인 scale 객체를 반환하는 메서드 채이닝 패턴을 따른다. 이를 통해서 호출 구문이 간결해지도록 여러개의 세터 사용이 가능하다.

Linear Scales

선형 스케일은 가장 일반적인 축척이다. 연속적인 정의역을 연속적인 치역으로 매핑하기에 좋은 선택이다. 이 매핑은 선형 매핑이다. 출력 범위값 y 는 입력 범위 값 x 에 관한 선형 함수 y = mx + b 로 표시할 수 있다. 일반적으로 정의역는 시각화하기를 원하는 데이터의 크기다. 예를 들면 표본 인구에서 학생들 키(단위가 미터)가 될 수 있다. 치역은 일반적으로 원하는 시각화 출력값의 크기이다. 예를 들면 바(histogram) 차트 안의 막대 높이(단위가 픽셀)가 치역에 해당한다.

# d3.scale.linear()

정의역이 [0,1]이고 치역이 [0,1]인 선형 스케일을 새로 생성한다. 그러므로 기본 선형 스케일은 항등함수와 같다. 예를 들어, linear(0.5)는 0.5를 반환한다.

# linear(x)

정의역에서 x 값을 주면 치역에서 상응하는 값을 반환한다.

# linear.invert(y)

치역내의 값 y 에 대한 정의역 x 의 값을 반환한다. 이 메서드는 치역에서 정의역으로의 역 매핑을 나타낸다. 치역의 유효한 값 y 에 대해서 linear(linear.invert( y ))는 y 와 같다. 그리고 정의역의 유효한 값 x 에 대해서 linear.invert(linear( x ))는 x 와 같다. 이처럼 도메인과 치역을 서로 바꾼 새로운 축척을 빌드해서 반대로 동작하는 연산자를 생성할 수 있다. 반대로 동작하는 연산자는 상호작용에 특히 유용한데, 마우스가 위치한 픽셀에 관련된 정의역의 값을 끌어내는데 사용한다.

주의: invert() 연산자는 숫자로 된 치역만 지원한다! 직렬화 제곱라미터 t 를 치역의 값과 매핑하는데 사용하는 d3.interpolate 나 사용자 지정 인터폴레이터의 지원으로 D3는 치역에 모든 타입을 둘 수 있다. 따라서 치역은 색상, 문자열 뿐 아니라 임의의 객체도 가능하다. 임의의 타입을 역보간 할 재주는 없으므로 invert 연산자는 현재 숫자형 치역만 지원한다.

# linear.domain([numbers])

numbers를 인자로 넘기면 지정한 숫자 배열로 스케일의 정의역를 지정한다. 배열에는 두 개 이상의 숫자가 있어야 한다. 인자로 넘긴 배열의 원소가 숫자가 아니면, 숫자로 변경한다. 이 변경은 스케일이 호출될 때 비슷하게 일어난다. 그러므로 숫자로 변환이 가능한 자바스크립트의 date 객체 같은 타입을 인코딩하기 위해서 선형 스케일을 사용할 수도 있다. 그러나 이 목적이라면 d3.time.scale를 사용하는 게 더 편하다. (여러분은 valueOf를 이용해서 변환 가능한 숫자형 객체를 구현할 수 있다. 링크 참조.) numbers 인자 없이 호출하면 현재 정의역을 반환한다.

선형 스케일이 일반적으로 정의역으로 두개의 숫자 값을 가지긴 하지만, 다선형 스케일(polylinear scale)를 위해서는 두개 이상의 값을 지정할 수 있다. 이런 경우, 치역의 값의 수도 정의역과 같아야 한다. 다선형 스케일은 연속적인 정의역과 치역을 분할해서 여러개의 불연속 선형 스케일을 표현한다. 이 방식은 정량적 축척(quantitative scale)을 분할해서 정의하고자 할 때 특히 유용하다. 예를 들어, 다음은 음수 값은 흰색과 빨강색 사이를 보간하고, 양수 값은 흰색과 초록색 사이를 보간하는 경우다.

var color = d3.scale.linear()
    .domain([-1, 0, 1])
    .range(["red", "white", "green"]);

color(-.5) 의 결과 값은 "#ff8080"이고, color(.5)의 결과값은 "#80c080"이다. 내부적으로 다선형 스케일은 주어진 정의역 값으로 관련된 출력 인터폴레이터를 위한 바이너리 검색을 수행한다. 정의역과 치역 모두의 값을 좀더 반복해서 늘리면, 정의역의 한 구역(chunk)이 치역에서 지정된 하나의 값(constant)으로 강제할 수도 있다.

# linear.range([values])

values 인자를 지정하면, 그 배열 값으로 스케일의 치역을 지정한다. 전달인자로 받는 배열은 정의역과 개수를 맞추어야 하므로, 두 개 이상의 값이 있어야 한다. 배열의 원소는 꼭 숫자여야 할 필요는 없다. 근본적으로 interpolator의 지원을 받는 모든 값이 동작한다. 하지만 invert 연산자를 위해서는 반드시 숫자형 치역이여야 한다. values 를 지정하지 않으면, 스케일의 현재 치역을 반환한다.

# linear.rangeRound(values)

지정한 전달인자 values 배열로 스케일의 치역을 지정한다. 단, 스케일에 사용할 인터폴레이터로 d3.interpolateRound를 지정한다.이는 안티알리아싱의 흔적을 지우는 경우처럼 스케일의 치역이 정확히 정수여야 할 때 유용하다. 또한 스케일 적용 후에 수동으로 치역을 반올림할 때도 사용할 수 있다.

# linear.interpolate([factory])

전달인자 factory 를 넘기면 스케일의 치역을 위한 인터폴레이터로 factory 를 지정한다. 기본 인터폴레이터는 d3.interpolate이며, 이를 [0,1] 범위의 정의역 파라미너 *t 를 치역의 관련 값으로 매핑하는데 사용한다. 즉 인터폴레이터 팩토리 함수는 치역의 각 인접 값들을 위해 값을 보정하는 인터폴레이터 인스턴스를 생성하기 위해서 사용된다.factory 인자를 지정하지 않으면, 해당 스케일의 인터폴레이터 팩토리를 반환한다.

# linear.clamp([boolean])

지정한 boolean 에 따라서 치역 범위를 한정하거나 하지않는다. 기본값은 치역 범위 한정을 하지 않는다. (boolean = false) 일반적으로 정의역 범위 밖의 값이 스케일로 전달되면, 그 스케일은 선형 외삽법(linear extrapolation)을 통해서 치역 바깥쪽의 값을 반환한다. 예를 들어, 정의역과 치역이 모두 [0,1]인 기본 스케일에 2를 입력값으로 넣으면 출력값도 2가 된다. 범위를 한정하면(boolean이 true이면) 정규화된 정의역 파라미터 t 이 치역 [0,1]로 고정된다. 즉, 스케일의 반환 값은 언제나 그 치역 안에 있다. boolean 을 지정하지 않으면, 치역의 범위를 한정하고 있는지 아닌지를 반환한다.

# linear.nice()

정의역을 깔끔한 반올림 값으로 시작하고 끝나도록 확장한다. 이 메서드는 스케일의 정의역을 수정해서 가장 근접한 반올림 값으로 정의역의 경계를 확장한다. 반올림 값의 정확도는 공식 exp(round(log( dx )) - 1) 의 dx 에 의존한다. 이 메서드는 정의역을 데이터에서 가져오는데 그 데이터가 잘 정제된 값이 아닐 때 유용하다. 예를 들어. 정의역이 [0.20147987687960267, 0.996679553296417]라면 nice 메서드를 통한 깔끔한 정의역은 [0.2, 1]이다. 정의역의 값이 두 개 이상이면, nice는 첫 값과 마지막 값만 영향을 준다.

# linear.ticks(count)

해당 스케일의 입력 도메인에서 대략 count 수 만큼의 대표값들을 반환한다. 반환되는 구분 값들은 사람이 읽기 좋은 10배수 값으로 고르게 등간격으로 분포해 있고, 정의역 확장에도 안전한다. 정의역을 구분하는 대표 구분값은 시각화된 데이터에서 참조용 라인이나 구분 마커를 보여주는데 사용된다. 전달인자인 count 는 단순 참조값으로, 스케일은 정의역을 근거로 count 보다 좀더 많거나 적은 값을 반환한다.

# linear.tickFormat(count)

출력용 구분자(tick) 값으로 사용할 적절한 number format 함수를 반환한다. 전달인자 count 는 구분값을 생성하기 위해서 사용되는 count 와 같은 값을 사용해야 한다. 구분자 출력을 위해서 꼭 스케일 내장 구분자 포맷터인 이 메서드를 사용할 필요는 없지만, 이 메서드는 이미 지정된 구분자 간격에 기반해서 관련 정확도를 자동으로 계산한다.

# linear.copy()

해당 선형 스케일의 정밀 복제를 반환한다. 해당 스케일의 변화는 반환 스케일에 영향을 주지 않는다. 반대도 마찬가지다.

Identity Scales

항등 스케일은 정의역과 치역이 동일한 선형 스케일의 특별한 케이스다. 이 스케일와 invert 메서드는 모두 항등함수다. 이 스케일은 axis and brush 컴포넌트와 함께 결합해서 픽셀 좌표 작업할 때 유용하다.

# d3.scale.identity()

기본 정의역과 치역을 [0, 1]로 하는 항등 스케일을 새로 생성한다. 항등 스케일은 항등 함수로서 항상 동등하다.

# identity(x)
# identity.invert(x)

주어진 x를 반환한다.

# identity.domain([numbers])
# identity.range([numbers])

numbers 인자를 지정하면, 그 배열의 숫자로 정의역(domain)과 치역(range)을 지정한다. 주어진 배열의 원소가 숫자가 아니면 숫자로 강재 변경을 한다. 이 강제 변경은 스케일이 호출 될 때와 비슷게 일어난다. 숫자를 지정하지 않으면, 현재 정의역을 반환한다. (치역도 동일하다.)

# identity.ticks(count)

해당 스케일의 입력도메인에서 대략 count 수 만큼의 대표값들을 반환한다. 반환되는 구분 값들은 사람들이 읽기 좋은 값(10의 배수들 처럼)으로 등간격으로 고르게 분포해있고, 정의역 확장에도 안전한다.정의역을 구분하는 대표 구분값은 시각화된 데이터에서 참조 라인이나 구분 마커를 보여주는데 사용된다. 전달인자인 count는 단순 참조값이다. 스케일은 정의역을 근거로 좀더 많거나 적은 값을 반환한다.

# identity.tickFormat(count)

출력용 구분자(tick) 값으로 사용할 적절한 number format 함수를 반환한다. 전달인자 count 는 구분값을 생성하기 위해서 사용되는 count과 같은 값을 사용해야 한다. 스케일 내장 tick format을 사용할 필요는 없지만, 구분값 사이의 고정된 간격 기반의 관련 정확도를 자동으로 계산한다.

# identity.copy()

해당 선형 스케일의 정밀 복제를 반환한다. 해당 스케일의 변화는 반환 스케일에 영향을 주지 않는다. 반대도 마찬가지다

Power Scales

제곱 스케일은 선형 스케일과 비슷하지만, 치역을 계산하기 전에 정의역에 지수 전환을 적용한다는 사실이 다르다. 치역 값 y 로 매핑은 정의역 값 x 의 지수 함수로 표현될 수 있다. y = mx^k + b. k 가 지수값이다. 제곱 스케일은 정의역 값에 -1을 곱해서 음수 값도 지원한다. 그러면 치역 값에도 -1을 곱한다.

# d3.scale.sqrt()

정의역과 치역이 [0,1]이고 지수가 0.5(1/2)인 제곱 스케일을 생성한다. 이 메서드는 다음 표현의 축약형이다.

d3.scale.pow().exponent(.5)

반환되는 스케일은 단일 인자로 정의역의 한 값인 x 를 받는 함수다. 이 함수는 입력값에 상응하는 치역의 값을 반환한다. 이처럼 이 스케일은 숫자를 위한 sqrt와 동일하다. 예를 들어 sqrt(0.25)는 0.5를 반환한다.

# d3.scale.pow()

정의역과 치역이 [0,1]이고 지수가 1인 제곱 스케일을 생성한다. 이 기본 제곱 스케일은 숫자를 위한 항등 함수와 동일하다. 예를 들어. pow(0.5)은 0.5를 반환한다.

# pow(x)

정의역의 x 값을 주면, 이에 상응하는 치역의 값을 반환한다.

# pow.invert(y)

치역의 값 y 에 상응하는 정의역 값 x 를 반환한다. 이 메서드는 치역을 정의역으로 역 매핑한다. 치역에 유효한 값 y 에 대해서 pow(pow.invert( y ))는 y 와 같다. 정의역의 유요한 값 x 에 대해서 pow.invert(pow( x ))는 x 와 같다. 동일하게 정의역과 치역을 뒤바꾼 새로운 스케일을 빌드함으로 invert 연산자를 생성할 수 있다. invert 연산자는 마우스 위치의 픽셀값으로 연관된 정의역 값을 찾는 상호작용을 구현하는데 유용하다.

주의: invert 연산자는 치역이 숫자인 경우만 지원한다! 직렬화 제곱라미터 t 를 치역의 값과 매핑하는데 사용하는 d3.interpolate 나 사용자 지정 인터폴레이터의 지원으로 D3는 치역에 모든 타입을 둘 수 있다. 따라서 치역은 색상, 문자열 뿐 아니라 임의의 객체도 가능하다. 임의의 타입을 "역보간(uninterpolate)" 할 재주는 없으므로 invert 연산자는 현재 숫자형 치역만 지원한다.

# pow.domain([numbers])

전달인자 numbers 를 지정하면 지정한 숫자 배열로 스케일의 정의역을 지정한다. 인자 배열은 두 개 이상의 숫자가 있어야 한다. 배열의 원소가 숫자가 아니면 강제로 숫자와 한다. 이 강제 변환은 이 스케일을 호출할 때도 비슷하게 발생한다.이와 같이 제곱 스케일은 숫자로 변환될 수 있는 모든 타입을 인코딩하기 위해서 사용될 수있다. numbers를 지정하지 않으면 스케일의 현재 정의역을 반환한다.

선형 스케일처럼, ( linear.domain 참조 ) 제곱 스케일도 정의역과 치역을 지정할 때 두 개 이상의 값을 사용할 수 있다. 이처럼 결과는 다재곱 스케일(polypower scale)이다.

# pow.range([values])

values 인자를 지정하면, 그 배열 값으로 스케일의 치역을 지정한다. 전달인자로 받는 배열은 정의역과 개수를 맞추어야 하므로, 두 개 이상의 값이 있어야 한다. 배열의 원소는 꼭 숫자여야 할 필요는 없다. 근본적으로 interpolator의 지원을 받는 모든 값이 동작한다. 하지만 invert 연산자를 위해서는 반드시 숫자형 치역이여야 한다. values 를 지정하지 않으면, 스케일의 현재 치역을 반환한다.

# pow.rangeRound(values)

지정한 전달인자 values 배열로 스케일의 치역을 지정한다. 단, 스케일에 사용할 인터폴레이터로 d3.interpolateRound를 지정한다.이는 안티알리아싱의 흔적을 지우는 경우처럼 스케일의 치역이 정확히 정수여야 할 때 유용하다. 또한 스케일 적용 후에 수동으로 치역을 반올림할 때도 사용할 수 있다.

# pow.exponent([k])

전달인자 k를 지정하면, 현재 지수값을 덥어쓴다. k 를 지정하지 않으면 현재 지수값을 반환한다. 기본값은 1이다.

# pow.interpolate([factory])

전달인자 factory 를 넘기면 스케일의 치역을 위한 인터폴레이터로 factory 를 지정한다. 기본 인터폴레이터는 d3.interpolate이며, 이를 [0,1] 범위의 정의역 파라미너 *t 를 치역의 관련 값으로 매핑하는데 사용한다. 즉 인터폴레이터 팩토리 함수는 치역의 각 인접 값들을 위해 값을 보정하는 인터폴레이터 인스턴스를 생성하기 위해서 사용된다.factory 인자를 지정하지 않으면, 해당 스케일의 인터폴레이터 팩토리를 반환한다.

# pow.clamp([boolean])

지정한 boolean 에 따라서 치역 범위를 한정하거나 하지않는다. 기본값은 치역 범위 한정을 하지 않는다. (boolean = false) 일반적으로 정의역 범위 밖의 값이 스케일로 전달되면, 그 스케일은 선형 외삽법(linear extrapolation)을 통해서 치역 바깥쪽의 값을 반환한다. 예를 들어, 정의역과 치역이 모두 [0,1]인 기본 스케일에 2를 입력값으로 넣으면 출력값도 2가 된다. 범위를 한정하면(boolean이 true이면) 정규화된 정의역 파라미터 t 이 치역 [0,1]로 고정된다. 즉, 스케일의 반환 값은 언제나 그 치역 안에 있다. boolean 을 지정하지 않으면, 치역의 범위를 한정하고 있는지 아닌지를 반환한다.

# pow.nice()

정의역을 깔끔한 반올림 값으로 시작하고 끝나도록 확장한다. 이 메서드는 스케일의 정의역을 수정해서 가장 근접한 반올림 값으로 정의역의 경계를 확장한다. 반올림 값의 정확도는 공식 exp(round(log( dx )) - 1) 의 dx 에 의존한다. 이 메서드는 정의역을 데이터에서 가져오는데 그 데이터가 잘 정제된 값이 아닐 때 유용하다. 예를 들어. 정의역이 [0.20147987687960267, 0.996679553296417]라면 nice 메서드를 통한 깔끔한 정의역은 [0.2, 1]이다. 정의역의 값이 두 개 이상이면, nice는 첫 값과 마지막 값만 영향을 준다.

# pow.ticks([count])

해당 스케일의 입력 도메인에서 대략 count 수 만큼의 대표값들을 반환한다. 반환되는 구분 값들은 사람이 읽기 좋은 10배수 값으로 고르게 등간격으로 분포해 있고, 정의역 확장에도 안전한다. 정의역을 구분하는 대표 구분값은 시각화된 데이터에서 참조용 라인이나 구분 마커를 보여주는데 사용된다. 전달인자인 count 는 단순 참조값으로, 스케일은 정의역을 근거로 count 보다 좀더 많거나 적은 값을 반환한다.

# pow.tickFormat([count])

출력용 구분자(tick) 값으로 사용할 적절한 number format 함수를 반환한다. 전달인자 count 는 구분값을 생성하기 위해서 사용되는 count 와 같은 값을 사용해야 한다. 구분자 출력을 위해서 꼭 스케일 내장 구분자 포맷터인 이 메서드를 사용할 필요는 없지만, 이 메서드는 이미 지정된 구분자 간격에 기반해서 관련 정확도를 자동으로 계산한다.

# pow.copy()

해당 제곱 스케일의 정밀 복제를 반환한다. 해당 스케일의 변화는 반환 스케일에 영향을 주지 않는다. 반대도 마찬가지다.

Log Scales

로그 스케일은 선형 스케일과 비슷하지만, 치역을 계산하기 전에 정의역에 로그 전환을 적용한다는 사실이 다르다. 치역 값 y 로 매핑은 정의역 값 x 의 로그 함수로 표현될 수 있다. y = m log(x) + b . 로그 스케일은 정의역 값에 -1을 곱해서 음수 값도 지원한다. 그러면 치역 값에도 -1을 곱한다. 하지만 로그 스케일의 정의역은 0(zero) 가 포함되면 안된다. log(0) 는 음의 무한대(negative infinity)다.

자바스크립트에서 Math.log(0)의 값은 -Infinity다.

# d3.scale.log()

정의역이 [1,10] 이고 치역이 [0,1]인 상용 로그(밑수가 10인) 스케일을 새로 생성한다.

# log(x)

정의역의 값중에서 x 를 전달인자로 넘기면 치역에서 연관된 값을 반환한다.

# log.invert(y)

Returns the value in the input domain x for the corresponding value in the output range y. This represents the inverse mapping from range to domain. For a valid value y in the output range, log(log.invert(y)) equals y; similarly, for a valid value x in the input domain, log.invert(log(x)) equals x. Equivalently, you can construct the invert operator by building a new scale while swapping the domain and range. The invert operator is particularly useful for interaction, say to determine the value in the input domain that corresponds to the pixel location under the mouse.

Note: the invert operator is only supported if the output range is numeric! D3 allows the output range to be any type; under the hood, d3.interpolate or a custom interpolator of your choice is used to map the normalized parameter t to a value in the output range. Thus, the output range may be colors, strings, or even arbitrary objects. As there is no facility to "uninterpolate" arbitrary types, the invert operator is currently supported only on numeric ranges.

# log.domain([values])

If numbers is specified, sets the scale's input domain to the specified array of numbers. The array must contain two or more numbers. If the elements in the given array are not numbers, they will be coerced to numbers; this coercion happens similarly when the scale is called. Thus, a log scale can be used to encode any type that can be converted to numbers. If numbers is not specified, returns the scale's current input domain.

As with linear scales (see linear.domain), log scales can also accept more than two values for the domain and range, thus resulting in polylog scale.

# log.range([values])

If values is specified, sets the scale's output range to the specified array of values. The array must contain two or more values, to match the cardinality of the input domain. The elements in the given array need not be numbers; any value that is supported by the underlying interpolator will work. However, numeric ranges are required for the invert operator. If values is not specified, returns the scale's current output range.

# log.rangeRound(values)

Sets the scale's output range to the specified array of values, while also setting the scale's interpolator to d3.interpolateRound. This is a convenience routine for when the values output by the scale should be exact integers, such as to avoid antialiasing artifacts. It is also possible to round the output values manually after the scale is applied.

# log.interpolate([interpolator])

If factory is specified, sets the scale's output interpolator using the specified factory. The interpolator factory defaults to d3.interpolate, and is used to map the normalized domain parameter t in [0,1] to the corresponding value in the output range. The interpolator factory will be used to construct interpolators for each adjacent pair of values from the output range. If factory is not specified, returns the scale's interpolator factory.

# log.clamp([boolean])

If boolean is specified, enables or disables clamping accordingly. By default, clamping is disabled, such that if a value outside the input domain is passed to the scale, the scale may return a value outside the output range through linear extrapolation. For example, with the default domain and range of [0,1], an input value of 2 will return an output value of 2. If clamping is enabled, the normalized domain parameter t is clamped to the range [0,1], such that the return value of the scale is always within the scale's output range. If boolean is not specified, returns whether or not the scale currently clamps values to within the output range.

# log.nice()

Extends the domain so that it starts and ends on nice round values. This method typically modifies the scale's domain, and may only extend the bounds to the nearest round value. The nearest round value is based on the nearest power of ten. Nicing is useful if the domain is computed from data and may be irregular. For example, for a domain of [0.20147987687960267, 0.996679553296417], the nice domain is [0.1, 1]. If the domain has more than two values, nicing the domain only affects the first and last value.

# log.ticks()

Returns representative values from the scale's input domain. The returned tick values are uniformly spaced within each power of ten, and are guaranteed to be within the extent of the input domain. Ticks are often used to display reference lines, or tick marks, in conjunction with the visualized data. Note that the number of ticks cannot be customized (due to the nature of log scales); however, you can filter the returned array of values if you want to reduce the number of ticks.

# log.tickFormat([count, [format]])

Returns a number format function suitable for displaying a tick value. The returned tick format is implemented as d.toPrecision(1). If a count is specified, then some of the tick labels may not be displayed; this is useful if there is not enough room to fit all of the tick labels. However, note that the tick marks will still be displayed (so that the log scale distortion remains visible). When specifying a count, you may also override the format function. For example, to display 20 ticks of a currency:

var formatNumber = d3.format(",.0f"), // for formatting integers
    formatCurrency = function(d) { return "$" + formatNumber(d); };

scale.ticks(20, formatCurrency);

# log.copy()

Returns an exact copy of this scale. Changes to this scale will not affect the returned scale, and vice versa.

Quantize Scales

Quantize scales are a variant of linear scales with a discrete rather than continuous range. The input domain is still continuous, and divided into uniform segments based on the number of values in (the cardinality of) the output range. The mapping is linear in that the output range value y can be expressed as a linear function of the input domain value x: y = mx + b. The input domain is typically a dimension of the data that you want to visualize, such as the height of students (measured in meters) in a sample population. The output range is typically a dimension of the desired output visualization, such as the height of bars (measured in pixels) in a histogram.

# d3.scale.quantize()

Constructs a new quantize scale with the default domain [0,1] and the default range [0,1]. Thus, the default quantize scale is equivalent to the round function for numbers; for example quantize(0.49) returns 0, and quantize(0.51) returns 1.

# quantize(x)

Given a value x in the input domain, returns the corresponding value in the output range.

# quantize.domain([numbers])

If numbers is specified, sets the scale's input domain to the specified two-element array of numbers. If the array contains more than two numbers, only the first and last number are used. If the elements in the given array are not numbers, they will be coerced to numbers; this coercion happens similarly when the scale is called. Thus, a quantize scale can be used to encode any type that can be converted to numbers. If numbers is not specified, returns the scale's current input domain.

# quantize.range([values])

If values is specified, sets the scale's output range to the specified array of values. The array may contain any number of discrete values. The elements in the given array need not be numbers; any value or type will work. If values is not specified, returns the scale's current output range.

# quantize.copy()

Returns an exact copy of this scale. Changes to this scale will not affect the returned scale, and vice versa.

Quantile Scales

Quantile scales map an input domain to a discrete range. Although the input domain is continuous and the scale will accept any reasonable input value, the input domain is specified as a discrete set of values. The number of values in (the cardinality of) the output range determines the number of quantiles that will be computed from the input domain. To compute the quantiles, the input domain is sorted, and treated as a population of discrete values. The input domain is typically a dimension of the data that you want to visualize, such as the daily change of the stock market. The output range is typically a dimension of the desired output visualization, such as a diverging color scale.

# d3.scale.quantile()

Constructs a new quantile scale with an empty domain and an empty range. The quantile scale is invalid until both a domain and range is specified.

# quantile(x)

Given a value x in the input domain, returns the corresponding value in the output range.

# quantile.domain([numbers])

If numbers is specified, sets the input domain of the quantile scale to the specified set of discrete numeric values. The array must not be empty, and must contain at least one numeric value; NaN, null and undefined values are ignored and not considered part of the sample population. If the elements in the given array are not numbers, they will be coerced to numbers; this coercion happens similarly when the scale is called. A copy of the input array is sorted and stored internally. Thus, a quantile scale can be used to encode any type that can be converted to numbers. If numbers is not specified, returns the scale's current input domain.

# quantile.range([values])

If values is specified, sets the discrete values in the output range. The array must not be empty, and may contain any type of value. The number of values in (the cardinality, or length, of) the values array determines the number of quantiles that are computed. For example, to compute quartiles, values must be an array of four elements such as [0, 1, 2, 3]. If values is not specified, returns the current output range.

# quantile.quantiles()

Returns the quantile thresholds. If the output range contains n discrete values, the returned threshold array will contain n - 1 values. Values less than the first element in the thresholds array, quantiles()[0], are considered in the first quantile; greater values less than the second threshold are in the second quantile, and so on. Internally, the thresholds array is used with d3.bisect to find the output quantile associated with the given input value.

# quantile.copy()

Returns an exact copy of this scale. Changes to this scale will not affect the returned scale, and vice versa.

Clone this wiki locally