खास जानकारी
ये फ़ंक्शन, इनपुट आर्ग्युमेंट को n-डाइमेंशनल स्पेस में वैक्टर के तौर पर दिखाते हैं.
32 बिट फ़्लोट पर किए जाने वाले गणितीय ऑपरेशन के सटीक होने पर, pragmas rs_fp_relaxed और rs_fp_full का असर पड़ता है. ज़्यादा जानकारी के लिए, गणितीय स्थिरांक और फ़ंक्शन लेख पढ़ें.
सामान्य गणित के फ़ंक्शन के वैरिएंट का इस्तेमाल करके, सटीक/तेज़ी से नतीजे पाने के लिए अलग-अलग विकल्प चुने जा सकते हैं. ऐसे फ़ंक्शन जिनका नाम
- native_: इसमें कस्टम हार्डवेयर लागू किए जा सकते हैं, लेकिन इनकी सटीक जानकारी नहीं मिलती. इसके अलावा, सबनॉर्मल वैल्यू को शून्य पर फ़्लश किया जा सकता है, शून्य के आस-पास की वैल्यू का इस्तेमाल किया जा सकता है, और NaN और अनंत इनपुट को सही तरीके से मैनेज नहीं किया जा सकता.
- fast_: 16 बिट फ़्लोट का इस्तेमाल करके, अंदरूनी कैलकुलेशन कर सकता है. इसके अलावा, सब-नॉर्मल वैल्यू को शून्य पर फ़्लश किया जा सकता है और शून्य के आस-पास की वैल्यू का इस्तेमाल किया जा सकता है.
खास जानकारी
| फ़ंक्शन | |
|---|---|
| क्रॉस | दो वेक्टर का क्रॉस प्रॉडक्ट |
| distance | दो बिंदुओं के बीच की दूरी |
| बिंदु | दो वैक्टर का डॉट प्रॉडक्ट |
| fast_distance | दो बिंदुओं के बीच की अनुमानित दूरी |
| fast_length | वेक्टर की अनुमानित लंबाई |
| fast_normalize | नॉर्मलाइज़ किया गया अनुमानित वेक्टर |
| लंबाई | वेक्टर की लंबाई |
| native_distance | दो बिंदुओं के बीच की अनुमानित दूरी |
| native_length | वेक्टर की अनुमानित लंबाई |
| native_normalize | किसी वेक्टर को करीब-करीब सामान्य करना |
| normalize | वेक्टर को सामान्य करना |
फ़ंक्शन
cross : दो वैक्टर का क्रॉस प्रॉडक्ट
| float3 cross(float3 left_vector, float3 right_vector); | |
| float4 cross(float4 left_vector, float4 right_vector); | |
| half3 cross(half3 left_vector, half3 right_vector); | एपीआई लेवल 24 में जोड़ा गया |
| half4 cross(half4 left_vector, half4 right_vector); | एपीआई लेवल 24 में जोड़ा गया |
दो वैक्टर का क्रॉस प्रॉडक्ट कैलकुलेट करता है.
distance : दो बिंदुओं के बीच की दूरी
| float distance(float left_vector, float right_vector); | |
| float distance(float2 left_vector, float2 right_vector); | |
| float distance(float3 left_vector, float3 right_vector); | |
| float distance(float4 left_vector, float4 right_vector); | |
| half distance(half left_vector, half right_vector); | एपीआई लेवल 24 में जोड़ा गया |
| half distance(half2 left_vector, half2 right_vector); | एपीआई लेवल 24 में जोड़ा गया |
| half distance(half3 left_vector, half3 right_vector); | एपीआई लेवल 24 में जोड़ा गया |
| half distance(half4 left_vector, half4 right_vector); | एपीआई लेवल 24 में जोड़ा गया |
दो बिंदुओं के बीच की दूरी का हिसाब लगाएं.
fast_distance(), native_distance() भी देखें.
dot : दो वैक्टर का डॉट प्रॉडक्ट
| float dot(float left_vector, float right_vector); | |
| float dot(float2 left_vector, float2 right_vector); | |
| float dot(float3 left_vector, float3 right_vector); | |
| float dot(float4 left_vector, float4 right_vector); | |
| half dot(half left_vector, half right_vector); | एपीआई लेवल 24 में जोड़ा गया |
| half dot(half2 left_vector, half2 right_vector); | एपीआई लेवल 24 में जोड़ा गया |
| half dot(half3 left_vector, half3 right_vector); | एपीआई लेवल 24 में जोड़ा गया |
| half dot(half4 left_vector, half4 right_vector); | एपीआई लेवल 24 में जोड़ा गया |
दो वैक्टर के डॉट प्रॉडक्ट का हिसाब लगाता है.
fast_distance : दो बिंदुओं के बीच की अनुमानित दूरी
| float fast_distance(float left_vector, float right_vector); | एपीआई लेवल 17 में जोड़ा गया |
| float fast_distance(float2 left_vector, float2 right_vector); | एपीआई लेवल 17 में जोड़ा गया |
| float fast_distance(float3 left_vector, float3 right_vector); | एपीआई लेवल 17 में जोड़ा गया |
| float fast_distance(float4 left_vector, float4 right_vector); | एपीआई लेवल 17 में जोड़ा गया |
दो बिंदुओं के बीच की अनुमानित दूरी का हिसाब लगाता है.
सटीक वैल्यू, 16 बिट फ़्लोटिंग-पॉइंट वैल्यू का इस्तेमाल करके कैलकुलेशन करने से मिलती है.
distance(), native_distance() भी देखें.
fast_length : किसी वेक्टर की अनुमानित लंबाई
| float fast_length(float v); | एपीआई लेवल 17 में जोड़ा गया |
| float fast_length(float2 v); | एपीआई लेवल 17 में जोड़ा गया |
| float fast_length(float3 v); | एपीआई लेवल 17 में जोड़ा गया |
| float fast_length(float4 v); | एपीआई लेवल 17 में जोड़ा गया |
किसी वेक्टर की अनुमानित लंबाई का हिसाब लगाता है.
सटीक वैल्यू, 16 बिट फ़्लोटिंग-पॉइंट वैल्यू का इस्तेमाल करके कैलकुलेशन करने से मिलती है.
length(), native_length() भी देखें.
fast_normalize : नॉर्मलाइज़ किया गया अनुमानित वेक्टर
| float fast_normalize(float v); | एपीआई लेवल 17 में जोड़ा गया |
| float2 fast_normalize(float2 v); | एपीआई लेवल 17 में जोड़ा गया |
| float3 fast_normalize(float3 v); | एपीआई लेवल 17 में जोड़ा गया |
| float4 fast_normalize(float4 v); | एपीआई लेवल 17 में जोड़ा गया |
किसी वेक्टर को करीब-करीब सामान्य बनाता है.
साइज़ 1 वाले वैक्टर के लिए, नेगेटिव वैल्यू के लिए -1.f, शून्य वैल्यू के लिए 0.f, और सकारात्मक वैल्यू के लिए 1.f दिखाता है.
16 बिट फ़्लोटिंग-पॉइंट वैल्यू का इस्तेमाल करके, कैलकुलेशन करने से उतनी ही सटीक वैल्यू मिलती है.
normalize(), native_normalize() भी देखें.
length : वेक्टर की लंबाई
| float length(float v); | |
| float length(float2 v); | |
| float length(float3 v); | |
| float length(float4 v); | |
| half length(half v); | एपीआई लेवल 24 में जोड़ा गया |
| half length(half2 v); | एपीआई लेवल 24 में जोड़ा गया |
| half length(half3 v); | एपीआई लेवल 24 में जोड़ा गया |
| half length(half4 v); | एपीआई लेवल 24 में जोड़ा गया |
किसी वेक्टर की लंबाई का हिसाब लगाता है.
fast_length(), native_length() भी देखें.
native_distance : दो बिंदुओं के बीच की अनुमानित दूरी
| float native_distance(float left_vector, float right_vector); | एपीआई लेवल 21 में जोड़ा गया |
| float native_distance(float2 left_vector, float2 right_vector); | एपीआई लेवल 21 में जोड़ा गया |
| float native_distance(float3 left_vector, float3 right_vector); | एपीआई लेवल 21 में जोड़ा गया |
| float native_distance(float4 left_vector, float4 right_vector); | एपीआई लेवल 21 में जोड़ा गया |
| half native_distance(half left_vector, half right_vector); | एपीआई लेवल 24 में जोड़ा गया |
| half native_distance(half2 left_vector, half2 right_vector); | एपीआई लेवल 24 में जोड़ा गया |
| half native_distance(half3 left_vector, half3 right_vector); | एपीआई लेवल 24 में जोड़ा गया |
| half native_distance(half4 left_vector, half4 right_vector); | एपीआई लेवल 24 में जोड़ा गया |
दो बिंदुओं के बीच की अनुमानित दूरी का हिसाब लगाता है.
distance(), fast_distance() भी देखें.
native_length : किसी वेक्टर की अनुमानित लंबाई
| float native_length(float v); | एपीआई लेवल 21 में जोड़ा गया |
| float native_length(float2 v); | एपीआई लेवल 21 में जोड़ा गया |
| float native_length(float3 v); | एपीआई लेवल 21 में जोड़ा गया |
| float native_length(float4 v); | एपीआई लेवल 21 में जोड़ा गया |
| half native_length(half v); | एपीआई लेवल 24 में जोड़ा गया |
| half native_length(half2 v); | एपीआई लेवल 24 में जोड़ा गया |
| half native_length(half3 v); | एपीआई लेवल 24 में जोड़ा गया |
| half native_length(half4 v); | एपीआई लेवल 24 में जोड़ा गया |
किसी वेक्टर की अनुमानित लंबाई का हिसाब लगाएं.
length(), fast_length() भी देखें.
native_normalize : किसी वेक्टर को लगभग नॉर्मलाइज़ करना
| float native_normalize(float v); | एपीआई लेवल 21 में जोड़ा गया |
| float2 native_normalize(float2 v); | एपीआई लेवल 21 में जोड़ा गया |
| float3 native_normalize(float3 v); | एपीआई लेवल 21 में जोड़ा गया |
| float4 native_normalize(float4 v); | एपीआई लेवल 21 में जोड़ा गया |
| half native_normalize(half v); | एपीआई लेवल 24 में जोड़ा गया |
| half2 native_normalize(half2 v); | एपीआई लेवल 24 में जोड़ा गया |
| half3 native_normalize(half3 v); | एपीआई लेवल 24 में जोड़ा गया |
| half4 native_normalize(half4 v); | एपीआई लेवल 24 में जोड़ा गया |
किसी वेक्टर को करीब-करीब सामान्य बनाता है.
normalize(), fast_normalize() भी देखें.
normalize : किसी वेक्टर को नॉर्मलाइज़ करना
| float normalize(float v); | |
| float2 normalize(float2 v); | |
| float3 normalize(float3 v); | |
| float4 normalize(float4 v); | |
| half normalize(half v); | एपीआई लेवल 24 में जोड़ा गया |
| half2 normalize(half2 v); | एपीआई लेवल 24 में जोड़ा गया |
| half3 normalize(half3 v); | एपीआई लेवल 24 में जोड़ा गया |
| half4 normalize(half4 v); | एपीआई लेवल 24 में जोड़ा गया |
वेक्टर को सामान्य करना.
साइज़ 1 वाले वैक्टर के लिए, नेगेटिव वैल्यू के लिए -1.f, शून्य वैल्यू के लिए 0.f, और सकारात्मक वैल्यू के लिए 1.f दिखाता है.
fast_normalize(), native_normalize() भी देखें.