RenderScript के गणितीय कॉन्स्टेंट और फ़ंक्शन

खास जानकारी

नीचे दिए गए गणितीय फ़ंक्शन, स्केलर और वैक्टर पर लागू किए जा सकते हैं. वैक्टर पर लागू करने पर, रिटर्न की गई वैल्यू, इनपुट की हर एंट्री पर लागू किए गए फ़ंक्शन का वैक्टर होती है.

उदाहरण के लिए:
float3 a, b;
// The following call sets
// a.x to sin(b.x),
// a.y to sin(b.y), and
// a.z to sin(b.z).
a = sin(b);

distance() और length() जैसे फ़ंक्शन के लिए वेक्टर मैथ फ़ंक्शन देखें. ये फ़ंक्शन, इनपुट को n-डाइमेंशनल स्पेस में एक वेक्टर के तौर पर समझते हैं.

32 बिट फ़्लोट पर किए जाने वाले गणितीय ऑपरेशन के सटीक होने पर, pragmas rs_fp_relaxed और rs_fp_full का असर पड़ता है. rs_fp_relaxed के तहत, सब-नॉर्मल वैल्यू को शून्य पर फ़्लश किया जा सकता है और वैल्यू को शून्य पर राउंड किया जा सकता है. इसकी तुलना में, rs_fp_full फ़ंक्शन में, सामान्य से कम वैल्यू को सही तरीके से मैनेज करना ज़रूरी है. जैसे, 1.17549435e-38f से कम वैल्यू. rs_fp_rull फ़ंक्शन के लिए, सबसे नज़दीकी संख्या पर राउंड करने की ज़रूरत होती है. साथ ही, बराबर होने पर उसे सम संख्या पर राउंड किया जाता है.

सामान्य गणित के फ़ंक्शन के वैरिएंट का इस्तेमाल करके, सटीक/तेज़ी से नतीजे पाने के लिए अलग-अलग विकल्प चुने जा सकते हैं. ऐसे फ़ंक्शन जिनका नाम

  • native_: इसमें कस्टम हार्डवेयर लागू किए जा सकते हैं, लेकिन इनकी सटीक जानकारी नहीं मिलती. इसके अलावा, सबनॉर्मल वैल्यू को शून्य पर फ़्लश किया जा सकता है, शून्य के आस-पास की वैल्यू का इस्तेमाल किया जा सकता है, और NaN और अनंत इनपुट को सही तरीके से मैनेज नहीं किया जा सकता.
  • half_: 16 बिट फ़्लोट का इस्तेमाल करके, अंदरूनी कैलकुलेशन कर सकता है. इसके अलावा, सब-नॉर्मल वैल्यू को शून्य पर फ़्लश किया जा सकता है और शून्य के आस-पास की वैल्यू का इस्तेमाल किया जा सकता है.

खास जानकारी

कॉन्स्टेंट
M_1_PI 1 / pi, 32-बिट फ़्लोट के तौर पर
M_2_PI 2 / pi, 32 बिट फ़्लोट के तौर पर
M_2_SQRTPI 2 / sqrt(pi), 32-बिट फ़्लोट के तौर पर
M_E e को 32-बिट फ़्लोट के तौर पर
M_LN10 log_e(10), 32-बिट फ़्लोट के तौर पर
M_LN2 log_e(2), 32-बिट फ़्लोट के तौर पर
M_LOG10E log_10(e), 32-बिट फ़्लोट के तौर पर
M_LOG2E log_2(e), 32-बिट फ़्लोट के तौर पर
M_PI pi, 32-बिट फ़्लोट के तौर पर
M_PI_2 pi / 2 को 32-बिट फ़्लोट के तौर पर
M_PI_4 pi / 4, 32 बिट फ़्लोट के तौर पर
M_SQRT1_2 1 / sqrt(2), 32 बिट फ़्लोट के तौर पर
M_SQRT2 sqrt(2), 32-बिट फ़्लोट के तौर पर
फ़ंक्शन
abs किसी पूर्णांक की ऐब्सलूट वैल्यू
acos इनवर्स कोसाइन
acosh इनवर्स हाइपरबोलिक कोसाइन
acospi इनवर्स कोसाइन को पाई से भाग दिया गया
asin इनवर्स साइन
asinh इनवर्स हाइपरबोलिक साइन
asinpi इनवर्स साइन को पाई से भाग दिया गया
atan इनवर्स टेंजेंट
atan2 किसी रेशियो का इनवर्स टेंजेंट
atan2pi किसी अनुपात के इनवर्स टेंजेंट को पाई से भाग दिया जाता है
atanh इनवर्स हाइपरबोलिक टेंजेंट
atanpi इनवर्स टेंजेंट को पाई से भाग दिया गया
cbrt घनमूल
ceil सबसे छोटा पूर्णांक, किसी वैल्यू से कम नहीं होना चाहिए
clamp किसी वैल्यू को किसी रेंज में सीमित करना
clz शुरुआत में मौजूद 0 बिट की संख्या
copysign किसी संख्या के साइन को दूसरी संख्या में कॉपी करता है
cos कोसाइन
cosh हाइपरबोलिक कोसाइन
cospi किसी संख्या को पाई से गुणा करने पर मिलने वाली कोसाइन
डिग्री रेडियन को डिग्री में बदलता है
erf गणितीय एरर फ़ंक्शन
erfc गणितीय कॉम्प्लीमेंट्री एरर फ़ंक्शन
exp किसी संख्या के घात में e
exp10 10 की किसी संख्या के साथ घात लगाना
exp2 2 की किसी संख्या के घात का मान
expm1 किसी संख्या को ई की घात में रखकर, उसमें से एक घटाना
fabs किसी फ़्लोट की ऐब्सलूट वैल्यू
fdim दो वैल्यू के बीच का पॉज़िटिव अंतर
फ़्लोर सबसे छोटा पूर्णांक, किसी वैल्यू से ज़्यादा नहीं होना चाहिए
fma गुणा और जोड़ना
fmax ज़्यादा से ज़्यादा दो फ़्लोट
fmin कम से कम दो फ़्लोट
fmod मॉड्यूलो
fract फ़्रैक्शनल पार्ट का धनात्मक होना
frexp बाइनरी मैन्टिसा और एक्सपोनेंट
half_recip 16 बिट तक सटीक वैल्यू के हिसाब से रिसिप्रोकल
half_rsqrt वर्गमूल का व्युत्क्रम, जिसे 16 बिट तक सटीक तौर पर कैलकुलेट किया जाता है
half_sqrt 16 बिट तक सटीक तरीके से निकाला गया वर्गमूल
hypot कर्ण
ilogb दो के आधार पर घातांक
ldexp मैन्टिसा और एक्सपोनेंट से फ़्लोटिंग पॉइंट बनाता है
lgamma गामा फ़ंक्शन का नेचुरल लॉगारिद्म
लॉग नेचुरल लॉगरिदम
log10 10 के आधार वाला लॉगारिदम
log1p किसी वैल्यू के साथ 1 जोड़कर उसका नेचुरल लॉगारिद्म
log2 बेस 2 लॉगारिदम
logb दो के आधार पर घातांक
mad गुणा और जोड़ना
max ज़्यादा से ज़्यादा
मिनट कम से कम
मिक्स करें दो वैल्यू को आपस में मिलाता है
modf पूर्णांक और भिन्न वाले कॉम्पोनेंट
nan यह कोई संख्या नहीं है
nan_half यह कोई संख्या नहीं है
native_acos अनुमानित इनवर्स कोसाइन
native_acosh अनुमानित इनवर्स हाइपरबोलिक कोसाइन
native_acospi अनुमानित इनवर्स कोसाइन को पाई से भाग दिया गया
native_asin इनवर्स साइन का अनुमान
native_asinh अनुमानित इनवर्स हाइपरबोलिक साइन
native_asinpi इनवर्स साइन के अनुमानित मान को पाई से भाग दिया गया
native_atan इनवर्स टेंजेंट का अनुमान
native_atan2 किसी अनुपात का अनुमानित इनवर्स टेंजेंट
native_atan2pi किसी अनुपात के इनवर्स टेंजेंट का अनुमानित मान, जिसे पाई से भाग दिया गया है
native_atanh इनवर्स हाइपरबोलिक टैंजेंट का अनुमान
native_atanpi अनुमानित इनवर्स टेंजेंट को पाई से भाग दिया गया
native_cbrt घनमूल का अनुमान
native_cos अनुमानित कोसाइन
native_cosh हाइपरबोलिक कोसाइन का अनुमान
native_cospi किसी संख्या को पाई से गुणा करने पर, कोसाइन का अनुमानित मान
native_divide अनुमानित डिवीज़न
native_exp किसी संख्या के साथ e का अनुमानित घातांक
native_exp10 10 की घात को किसी संख्या के आस-पास का अनुमान लगाना
native_exp2 किसी संख्या के लिए, 2 की घात का अनुमानित मान
native_expm1 किसी संख्या को एक से कम घात में, e के आस-पास का अनुमान
native_hypot कर्ण (हाइपोटेन्यूज़) का अनुमान
native_log नैचुरल लॉगरिदम का अनुमान
native_log10 10 के आधार वाला अनुमानित लॉगारिद्म
native_log1p किसी वैल्यू के साथ 1 जोड़कर, उसका अनुमानित नेचुरल लॉगारिद्म
native_log2 बेस 2 लॉगारिद्म का अनुमान
native_powr अनुमानित पॉज़िटिव बेस को घात में बढ़ाया गया
native_recip अनुमानित रिसिप्रोकल
native_rootn nवें मूल का अनुमान लगाना
native_rsqrt वर्गमूल का अनुमानित व्युत्क्रम
native_sin साइन फ़ंक्शन का अनुमानित वैल्यू
native_sincos साइन और कोसाइन का अनुमान लगाना
native_sinh हाइपरबोलिक साइन का अनुमान
native_sinpi किसी संख्या को पाई से गुणा करने पर, उसका अनुमानित साइन
native_sqrt अनुमानित वर्गमूल
native_tan टेंगेंट का अनुमान
native_tanh हाइपरबोलिक टैंजेंट का अनुमान
native_tanpi किसी संख्या को पाई से गुणा करने पर, उसका अनुमानित टैंजेंट
nextafter अगला फ़्लोटिंग पॉइंट नंबर
pow आधार को घात में बढ़ाना
pown बेस को पूर्णांक घातांक पर बढ़ाया गया
powr किसी घात में बढ़ाया गया पॉज़िटिव आधार
रेडियन डिग्री को रेडियन में बदलता है
बचे हुए भागफल में बचे हुए अंक
remquo भागफल और शेष
rint राउंड ऑफ़ करना
rootn एनवां रूट
round शून्य से दूर राउंड करना
rsRand स्यूडो-रैंडम नंबर
rsqrt वर्गमूल का व्युत्क्रम
sign वैल्यू का साइन
पाप साइन
sincos साइन और कोसाइन
sinh हाइपरबोलिक साइन
sinpi किसी संख्या को पाई से गुणा करने पर मिलने वाला साइन
sqrt वर्गमूल
step अगर वैल्यू किसी वैल्यू से कम है, तो 0 और अगर वैल्यू किसी वैल्यू से ज़्यादा है, तो 1
tan टेंगेंट
tanh हाइपरबोलिक टेंगेंट
tanpi किसी संख्या को पाई से गुणा करने पर, उसका टेंगेंट
tgamma गामा फ़ंक्शन
trunc फ़्लोटिंग पॉइंट को छोटा करता है
बंद किए गए फ़ंक्शन
rsClamp अब काम नहीं करता. किसी वैल्यू को किसी रेंज में सीमित करना
rsFrac अब काम नहीं करता. फ़्लोट वैल्यू के दशमलव वाले हिस्से को दिखाता है

कॉन्स्टेंट

M_1_PI : 1 / pi, 32 बिट फ़्लोट के तौर पर


वैल्यू: 0.318309886183790671537767526745028724f

पाई का इनवर्स, 32-बिट फ़्लोट के तौर पर.

M_2_PI : 2 / pi, 32 बिट फ़्लोट के तौर पर


वैल्यू: 0.636619772367581343075535053490057448f

2 को पाई से भाग दिया गया, जो 32 बिट फ़्लोट है.

M_2_SQRTPI : 2 / sqrt(pi), 32 बिट फ़्लोट के तौर पर


वैल्यू: 1.128379167095512573896158903121545172f

2 को पाई के वर्गमूल से भाग देने पर मिली संख्या, 32 बिट फ़्लोट के तौर पर.

M_E : e, 32 बिट फ़्लोट के तौर पर


वैल्यू: 2.718281828459045235360287471352662498f

नेचुरल लॉगारिद्म का आधार e, 32 बिट फ़्लोट के तौर पर.

M_LN10 : log_e(10), 32 बिट फ़्लोट के तौर पर


वैल्यू: 2.302585092994045684017991454684364208f

10 का नेचुरल लॉगारिद्म, 32-बिट फ़्लोट के तौर पर.

M_LN2 : log_e(2), 32 बिट फ़्लोट के तौर पर


वैल्यू: 0.693147180559945309417232121458176568f

32 बिट फ़्लोट के तौर पर, 2 का नेचुरल लॉगारिद्म.

M_LOG10E : log_10(e), 32 बिट फ़्लोट के तौर पर


वैल्यू: 0.434294481903251827651128918916605082f

e का लॉगारिद्म, जिसका आधार 10 है और यह 32 बिट फ़्लोट के तौर पर है.

M_LOG2E : log_2(e), 32 बिट फ़्लोट के तौर पर


वैल्यू: 1.442695040888963407359924681001892137f

e का लॉगारिद्म, जिसका आधार 2 है. इसे 32 बिट फ़्लोट के तौर पर दिखाया जाता है.

M_PI : पाई, 32 बिट फ़्लोट के तौर पर


वैल्यू: 3.141592653589793238462643383279502884f

pi का कॉन्स्टेंट, 32-बिट फ़्लोट के तौर पर.

M_PI_2 : pi / 2, 32-बिट फ़्लोट के तौर पर


वैल्यू: 1.570796326794896619231321691639751442f

पाई को 2 से भाग देने पर, 32-बिट फ़्लोट के तौर पर दिखेगा.

M_PI_4 : pi / 4, 32 बिट फ़्लोट के तौर पर


वैल्यू: 0.785398163397448309615660845819875721f

पाई को 4 से भाग देने पर मिली संख्या, 32-बिट फ़्लोट के तौर पर.

M_SQRT1_2 : 1 / sqrt(2), 32 बिट फ़्लोट के तौर पर


वैल्यू: 0.707106781186547524400844362104849039f

32 बिट फ़्लोट के तौर पर, 2 के वर्गमूल का उलटा.

M_SQRT2 : sqrt(2), 32 बिट फ़्लोट के तौर पर


वैल्यू: 1.414213562373095048801688724209698079f

32-बिट फ़्लोट के तौर पर, 2 का वर्गमूल.

फ़ंक्शन

abs : किसी पूर्णांक की पूर्ण वैल्यू

uchar abs(char v);
uchar2 abs(char2 v);
uchar3 abs(char3 v);
uchar4 abs(char4 v);
uint abs(int v);
uint2 abs(int2 v);
uint3 abs(int3 v);
uint4 abs(int4 v);
ushort abs(short v);
ushort2 abs(short2 v);
ushort3 abs(short3 v);
ushort4 abs(short4 v);

किसी पूर्णांक की ऐब्सलूट वैल्यू दिखाता है.

फ़्लोट के लिए, fabs() का इस्तेमाल करें.

acos : इनवर्स कोसाइन

float acos(float v);
float2 acos(float2 v);
float3 acos(float3 v);
float4 acos(float4 v);
half acos(half v); एपीआई लेवल 24 में जोड़ा गया
half2 acos(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 acos(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 acos(half4 v); एपीआई लेवल 24 में जोड़ा गया

रेडियन में इनवर्स कोसाइन दिखाता है.

native_acos() भी देखें.

acosh : हाइपरबोलिक कोसाइन का उलटा

float acosh(float v);
float2 acosh(float2 v);
float3 acosh(float3 v);
float4 acosh(float4 v);
half acosh(half v); एपीआई लेवल 24 में जोड़ा गया
half2 acosh(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 acosh(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 acosh(half4 v); एपीआई लेवल 24 में जोड़ा गया

रेडियन में इनवर्स हाइपरबोलिक कोसाइन दिखाता है.

native_acosh() भी देखें.

acospi : इनवर्स कोसाइन को पाई से भाग दिया जाता है

float acospi(float v);
float2 acospi(float2 v);
float3 acospi(float3 v);
float4 acospi(float4 v);
half acospi(half v); एपीआई लेवल 24 में जोड़ा गया
half2 acospi(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 acospi(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 acospi(half4 v); एपीआई लेवल 24 में जोड़ा गया

रेडियन में इनवर्स कोसाइन दिखाता है. इसमें पाई से भाग दिया जाता है.

डिग्री में मेज़र किए गए इनवर्स कोसाइन का पता लगाने के लिए, acospi(a) * 180.f का इस्तेमाल करें.

native_acospi() भी देखें.

asin : इनवर्स साइन

float asin(float v);
float2 asin(float2 v);
float3 asin(float3 v);
float4 asin(float4 v);
half asin(half v); एपीआई लेवल 24 में जोड़ा गया
half2 asin(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 asin(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 asin(half4 v); एपीआई लेवल 24 में जोड़ा गया

रेडियन में इनवर्स साइन दिखाता है.

native_asin() भी देखें.

asinh : इनवर्स हाइपरबोलिक साइन

float asinh(float v);
float2 asinh(float2 v);
float3 asinh(float3 v);
float4 asinh(float4 v);
half asinh(half v); एपीआई लेवल 24 में जोड़ा गया
half2 asinh(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 asinh(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 asinh(half4 v); एपीआई लेवल 24 में जोड़ा गया

रेडियन में इनवर्स हाइपरबोलिक साइन दिखाता है.

native_asinh() भी देखें.

asinpi : इनवर्स साइन को पाई से भाग दिया जाता है

float asinpi(float v);
float2 asinpi(float2 v);
float3 asinpi(float3 v);
float4 asinpi(float4 v);
half asinpi(half v); एपीआई लेवल 24 में जोड़ा गया
half2 asinpi(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 asinpi(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 asinpi(half4 v); एपीआई लेवल 24 में जोड़ा गया

रेडियन में इनवर्स साइन दिखाता है. इसमें पाई से भाग दिया जाता है.

डिग्री में मेज़र किए गए इनवर्स साइन का पता लगाने के लिए, asinpi(a) * 180.f का इस्तेमाल करें.

native_asinpi() भी देखें.

atan : इनवर्स टेंगेंट

float atan(float v);
float2 atan(float2 v);
float3 atan(float3 v);
float4 atan(float4 v);
half atan(half v); एपीआई लेवल 24 में जोड़ा गया
half2 atan(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 atan(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 atan(half4 v); एपीआई लेवल 24 में जोड़ा गया

रेडियन में इनवर्स टैंजेंट दिखाता है.

native_atan() भी देखें.

atan2 : किसी अनुपात का इनवर्स टेंगेंट

float atan2(float numerator, float denominator);
float2 atan2(float2 numerator, float2 denominator);
float3 atan2(float3 numerator, float3 denominator);
float4 atan2(float4 numerator, float4 denominator);
half atan2(half numerator, half denominator); एपीआई लेवल 24 में जोड़ा गया
half2 atan2(half2 numerator, half2 denominator); एपीआई लेवल 24 में जोड़ा गया
half3 atan2(half3 numerator, half3 denominator); एपीआई लेवल 24 में जोड़ा गया
half4 atan2(half4 numerator, half4 denominator); एपीआई लेवल 24 में जोड़ा गया
पैरामीटर
न्यूमरेटरअंश (न्यूमरेटर).
डिनोमिनेटरडिनोमिनेटर. यह 0 हो सकता है.

रेडियन में (numerator / denominator) का इनवर्स टैंजेंट दिखाता है.

native_atan2() भी देखें.

atan2pi : किसी रेशियो के इनवर्स टेंगेंट को पाई से भाग दिया जाता है

float atan2pi(float numerator, float denominator);
float2 atan2pi(float2 numerator, float2 denominator);
float3 atan2pi(float3 numerator, float3 denominator);
float4 atan2pi(float4 numerator, float4 denominator);
half atan2pi(half numerator, half denominator); एपीआई लेवल 24 में जोड़ा गया
half2 atan2pi(half2 numerator, half2 denominator); एपीआई लेवल 24 में जोड़ा गया
half3 atan2pi(half3 numerator, half3 denominator); एपीआई लेवल 24 में जोड़ा गया
half4 atan2pi(half4 numerator, half4 denominator); एपीआई लेवल 24 में जोड़ा गया
पैरामीटर
न्यूमरेटरअंश (न्यूमरेटर).
डिनोमिनेटरडिनोमिनेटर. यह 0 हो सकता है.

रेडियन में (numerator / denominator) के इनवर्स टैंजेंट को पाई से भाग देकर दिखाता है.

डिग्री में मेज़र किया गया इनवर्स टेंगेंट पाने के लिए, atan2pi(n, d) * 180.f का इस्तेमाल करें.

native_atan2pi() भी देखें.

atanh : इनवर्स हाइपरबोलिक टेंजेंट

float atanh(float v);
float2 atanh(float2 v);
float3 atanh(float3 v);
float4 atanh(float4 v);
half atanh(half v); एपीआई लेवल 24 में जोड़ा गया
half2 atanh(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 atanh(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 atanh(half4 v); एपीआई लेवल 24 में जोड़ा गया

रेडियन में इनवर्स हाइपरबोलिक टैंजेंट दिखाता है.

native_atanh() भी देखें.

atanpi : इनवर्स टेंगेंट को पाई से भाग दिया जाता है

float atanpi(float v);
float2 atanpi(float2 v);
float3 atanpi(float3 v);
float4 atanpi(float4 v);
half atanpi(half v); एपीआई लेवल 24 में जोड़ा गया
half2 atanpi(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 atanpi(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 atanpi(half4 v); एपीआई लेवल 24 में जोड़ा गया

रेडियन में इनवर्स टैंजेंट दिखाता है. इसमें पाई से भाग दिया जाता है.

डिग्री में मेज़र किया गया इनवर्स टेंगेंट पाने के लिए, atanpi(a) * 180.f का इस्तेमाल करें.

native_atanpi() भी देखें.

cbrt : घन रूट

float cbrt(float v);
float2 cbrt(float2 v);
float3 cbrt(float3 v);
float4 cbrt(float4 v);
half cbrt(half v); एपीआई लेवल 24 में जोड़ा गया
half2 cbrt(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 cbrt(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 cbrt(half4 v); एपीआई लेवल 24 में जोड़ा गया

घनमूल दिखाता है.

native_cbrt() भी देखें.

ceil : सबसे छोटा पूर्णांक, जो किसी वैल्यू से कम न हो

float ceil(float v);
float2 ceil(float2 v);
float3 ceil(float3 v);
float4 ceil(float4 v);
half ceil(half v); एपीआई लेवल 24 में जोड़ा गया
half2 ceil(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 ceil(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 ceil(half4 v); एपीआई लेवल 24 में जोड़ा गया

किसी वैल्यू से कम न होने वाला सबसे छोटा पूर्णांक दिखाता है.

उदाहरण के लिए, ceil(1.2f) से 2.f और ceil(-1.2f) से -1.f मिलता है.

floor() फ़ंक्शन के बारे में भी जानें.

clamp : किसी वैल्यू को रेंज में रखना

char clamp(char value, char min_value, char max_value); एपीआई लेवल 19 में जोड़ा गया
char2 clamp(char2 value, char min_value, char max_value); एपीआई लेवल 19 में जोड़ा गया
char2 clamp(char2 value, char2 min_value, char2 max_value); एपीआई लेवल 19 में जोड़ा गया
char3 clamp(char3 value, char min_value, char max_value); एपीआई लेवल 19 में जोड़ा गया
char3 clamp(char3 value, char3 min_value, char3 max_value); एपीआई लेवल 19 में जोड़ा गया
char4 clamp(char4 value, char min_value, char max_value); एपीआई लेवल 19 में जोड़ा गया
char4 clamp(char4 value, char4 min_value, char4 max_value); एपीआई लेवल 19 में जोड़ा गया
float clamp(float value, float min_value, float max_value);
float2 clamp(float2 value, float min_value, float max_value);
float2 clamp(float2 value, float2 min_value, float2 max_value);
float3 clamp(float3 value, float min_value, float max_value);
float3 clamp(float3 value, float3 min_value, float3 max_value);
float4 clamp(float4 value, float min_value, float max_value);
float4 clamp(float4 value, float4 min_value, float4 max_value);
half clamp(half value, half min_value, half max_value); एपीआई लेवल 24 में जोड़ा गया
half2 clamp(half2 value, half min_value, half max_value); एपीआई लेवल 24 में जोड़ा गया
half2 clamp(half2 value, half2 min_value, half2 max_value); एपीआई लेवल 24 में जोड़ा गया
half3 clamp(half3 value, half min_value, half max_value); एपीआई लेवल 24 में जोड़ा गया
half3 clamp(half3 value, half3 min_value, half3 max_value); एपीआई लेवल 24 में जोड़ा गया
half4 clamp(half4 value, half min_value, half max_value); एपीआई लेवल 24 में जोड़ा गया
half4 clamp(half4 value, half4 min_value, half4 max_value); एपीआई लेवल 24 में जोड़ा गया
int clamp(int value, int min_value, int max_value); एपीआई लेवल 19 में जोड़ा गया
int2 clamp(int2 value, int min_value, int max_value); एपीआई लेवल 19 में जोड़ा गया
int2 clamp(int2 value, int2 min_value, int2 max_value); एपीआई लेवल 19 में जोड़ा गया
int3 clamp(int3 value, int min_value, int max_value); एपीआई लेवल 19 में जोड़ा गया
int3 clamp(int3 value, int3 min_value, int3 max_value); एपीआई लेवल 19 में जोड़ा गया
int4 clamp(int4 value, int min_value, int max_value); एपीआई लेवल 19 में जोड़ा गया
int4 clamp(int4 value, int4 min_value, int4 max_value); एपीआई लेवल 19 में जोड़ा गया
long clamp(long value, long min_value, long max_value); एपीआई लेवल 19 में जोड़ा गया
long2 clamp(long2 value, long min_value, long max_value); एपीआई लेवल 19 में जोड़ा गया
long2 clamp(long2 value, long2 min_value, long2 max_value); एपीआई लेवल 19 में जोड़ा गया
long3 clamp(long3 value, long min_value, long max_value); एपीआई लेवल 19 में जोड़ा गया
long3 clamp(long3 value, long3 min_value, long3 max_value); एपीआई लेवल 19 में जोड़ा गया
long4 clamp(long4 value, long min_value, long max_value); एपीआई लेवल 19 में जोड़ा गया
long4 clamp(long4 value, long4 min_value, long4 max_value); एपीआई लेवल 19 में जोड़ा गया
short clamp(short value, short min_value, short max_value); एपीआई लेवल 19 में जोड़ा गया
short2 clamp(short2 value, short min_value, short max_value); एपीआई लेवल 19 में जोड़ा गया
short2 clamp(short2 value, short2 min_value, short2 max_value); एपीआई लेवल 19 में जोड़ा गया
short3 clamp(short3 value, short min_value, short max_value); एपीआई लेवल 19 में जोड़ा गया
short3 clamp(short3 value, short3 min_value, short3 max_value); एपीआई लेवल 19 में जोड़ा गया
short4 clamp(short4 value, short min_value, short max_value); एपीआई लेवल 19 में जोड़ा गया
short4 clamp(short4 value, short4 min_value, short4 max_value); एपीआई लेवल 19 में जोड़ा गया
uchar clamp(uchar value, uchar min_value, uchar max_value); एपीआई लेवल 19 में जोड़ा गया
uchar2 clamp(uchar2 value, uchar min_value, uchar max_value); एपीआई लेवल 19 में जोड़ा गया
uchar2 clamp(uchar2 value, uchar2 min_value, uchar2 max_value); एपीआई लेवल 19 में जोड़ा गया
uchar3 clamp(uchar3 value, uchar min_value, uchar max_value); एपीआई लेवल 19 में जोड़ा गया
uchar3 clamp(uchar3 value, uchar3 min_value, uchar3 max_value); एपीआई लेवल 19 में जोड़ा गया
uchar4 clamp(uchar4 value, uchar min_value, uchar max_value); एपीआई लेवल 19 में जोड़ा गया
uchar4 clamp(uchar4 value, uchar4 min_value, uchar4 max_value); एपीआई लेवल 19 में जोड़ा गया
uint clamp(uint value, uint min_value, uint max_value); एपीआई लेवल 19 में जोड़ा गया
uint2 clamp(uint2 value, uint min_value, uint max_value); एपीआई लेवल 19 में जोड़ा गया
uint2 clamp(uint2 value, uint2 min_value, uint2 max_value); एपीआई लेवल 19 में जोड़ा गया
uint3 clamp(uint3 value, uint min_value, uint max_value); एपीआई लेवल 19 में जोड़ा गया
uint3 clamp(uint3 value, uint3 min_value, uint3 max_value); एपीआई लेवल 19 में जोड़ा गया
uint4 clamp(uint4 value, uint min_value, uint max_value); एपीआई लेवल 19 में जोड़ा गया
uint4 clamp(uint4 value, uint4 min_value, uint4 max_value); एपीआई लेवल 19 में जोड़ा गया
ulong clamp(ulong value, ulong min_value, ulong max_value); एपीआई लेवल 19 में जोड़ा गया
ulong2 clamp(ulong2 value, ulong min_value, ulong max_value); एपीआई लेवल 19 में जोड़ा गया
ulong2 clamp(ulong2 value, ulong2 min_value, ulong2 max_value); एपीआई लेवल 19 में जोड़ा गया
ulong3 clamp(ulong3 value, ulong min_value, ulong max_value); एपीआई लेवल 19 में जोड़ा गया
ulong3 clamp(ulong3 value, ulong3 min_value, ulong3 max_value); एपीआई लेवल 19 में जोड़ा गया
ulong4 clamp(ulong4 value, ulong min_value, ulong max_value); एपीआई लेवल 19 में जोड़ा गया
ulong4 clamp(ulong4 value, ulong4 min_value, ulong4 max_value); एपीआई लेवल 19 में जोड़ा गया
ushort clamp(ushort value, ushort min_value, ushort max_value); एपीआई लेवल 19 में जोड़ा गया
ushort2 clamp(ushort2 value, ushort min_value, ushort max_value); एपीआई लेवल 19 में जोड़ा गया
ushort2 clamp(ushort2 value, ushort2 min_value, ushort2 max_value); एपीआई लेवल 19 में जोड़ा गया
ushort3 clamp(ushort3 value, ushort min_value, ushort max_value); एपीआई लेवल 19 में जोड़ा गया
ushort3 clamp(ushort3 value, ushort3 min_value, ushort3 max_value); एपीआई लेवल 19 में जोड़ा गया
ushort4 clamp(ushort4 value, ushort min_value, ushort max_value); एपीआई लेवल 19 में जोड़ा गया
ushort4 clamp(ushort4 value, ushort4 min_value, ushort4 max_value); एपीआई लेवल 19 में जोड़ा गया
पैरामीटर
मानक्लैंप की जाने वाली वैल्यू.
min_valueनिचली सीमा, स्केलर या मैच करने वाला वेक्टर.
max_valueऊपरी सीमा, निचली सीमा के टाइप से मेल खानी चाहिए.

किसी वैल्यू को तय की गई ऊपरी और निचली सीमा के बीच रखता है. clamp() फ़ंक्शन, वैल्यू के min_value से कम होने पर min_value, वैल्यू के max_value से ज़्यादा होने पर max_value दिखाता है. इसके अलावा, वैल्यू के बराबर होने पर वैल्यू दिखाता है.

क्लैंप के दो वैरिएंट होते हैं: पहला, जहां वैल्यू की सभी एंट्री पर कम से कम और ज़्यादा से ज़्यादा वैल्यू स्केलर के तौर पर लागू होती हैं. दूसरा, जहां कम से कम और ज़्यादा से ज़्यादा वैल्यू वेक्टर के तौर पर भी लागू होती हैं.

अगर min_value, max_value से ज़्यादा है, तो नतीजे तय नहीं किए जाते.

clz : शुरुआत में मौजूद 0 बिट की संख्या

char clz(char value);
char2 clz(char2 value);
char3 clz(char3 value);
char4 clz(char4 value);
int clz(int value);
int2 clz(int2 value);
int3 clz(int3 value);
int4 clz(int4 value);
short clz(short value);
short2 clz(short2 value);
short3 clz(short3 value);
short4 clz(short4 value);
uchar clz(uchar value);
uchar2 clz(uchar2 value);
uchar3 clz(uchar3 value);
uchar4 clz(uchar4 value);
uint clz(uint value);
uint2 clz(uint2 value);
uint3 clz(uint3 value);
uint4 clz(uint4 value);
ushort clz(ushort value);
ushort2 clz(ushort2 value);
ushort3 clz(ushort3 value);
ushort4 clz(ushort4 value);

किसी वैल्यू में शुरुआती 0-बिट की संख्या दिखाता है.

उदाहरण के लिए, clz((char)0x03) से 6 मिलता है.

copysign : किसी संख्या के साइन को किसी दूसरी संख्या में कॉपी करता है

float copysign(float magnitude_value, float sign_value);
float2 copysign(float2 magnitude_value, float2 sign_value);
float3 copysign(float3 magnitude_value, float3 sign_value);
float4 copysign(float4 magnitude_value, float4 sign_value);
half copysign(half magnitude_value, half sign_value); एपीआई लेवल 24 में जोड़ा गया
half2 copysign(half2 magnitude_value, half2 sign_value); एपीआई लेवल 24 में जोड़ा गया
half3 copysign(half3 magnitude_value, half3 sign_value); एपीआई लेवल 24 में जोड़ा गया
half4 copysign(half4 magnitude_value, half4 sign_value); एपीआई लेवल 24 में जोड़ा गया

sign_value से magnitude_value में साइन कॉपी करता है.

लौटाई गई वैल्यू, magnitude_value या -magnitude_value होती है.

उदाहरण के लिए, copysign(4.0f, -2.7f) से -4.0f और copysign(-4.0f, 2.7f) से 4.0f मिलता है.

cos : कोसाइन

float cos(float v);
float2 cos(float2 v);
float3 cos(float3 v);
float4 cos(float4 v);
half cos(half v); एपीआई लेवल 24 में जोड़ा गया
half2 cos(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 cos(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 cos(half4 v); एपीआई लेवल 24 में जोड़ा गया

रेडियन में मापे गए कोण का कोसाइन दिखाता है.

native_cos() भी देखें.

cosh : हाइपरबोलिक कोसाइन

float cosh(float v);
float2 cosh(float2 v);
float3 cosh(float3 v);
float4 cosh(float4 v);
half cosh(half v); एपीआई लेवल 24 में जोड़ा गया
half2 cosh(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 cosh(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 cosh(half4 v); एपीआई लेवल 24 में जोड़ा गया

v का हाइपरबोलिक कोसाइन दिखाता है. v को रेडियन में मेज़र किया जाता है.

native_cosh() भी देखें.

cospi : किसी संख्या को पाई से गुणा करने पर मिलने वाली संख्या का कोसाइन

float cospi(float v);
float2 cospi(float2 v);
float3 cospi(float3 v);
float4 cospi(float4 v);
half cospi(half v); एपीआई लेवल 24 में जोड़ा गया
half2 cospi(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 cospi(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 cospi(half4 v); एपीआई लेवल 24 में जोड़ा गया

(v * pi) का कोसाइन दिखाता है. (v * pi) को रेडियन में मेज़र किया जाता है.

डिग्री में मेज़र की गई वैल्यू का कोसाइन पाने के लिए, cospi(v / 180.f) को कॉल करें.

native_cospi() भी देखें.

degrees : रेडियन को डिग्री में बदलता है

float degrees(float v);
float2 degrees(float2 v);
float3 degrees(float3 v);
float4 degrees(float4 v);
half degrees(half v); एपीआई लेवल 24 में जोड़ा गया
half2 degrees(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 degrees(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 degrees(half4 v); एपीआई लेवल 24 में जोड़ा गया

रेडियन को डिग्री में बदलता है.

erf : गणितीय गड़बड़ी फ़ंक्शन

float erf(float v);
float2 erf(float2 v);
float3 erf(float3 v);
float4 erf(float4 v);
half erf(half v); एपीआई लेवल 24 में जोड़ा गया
half2 erf(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 erf(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 erf(half4 v); एपीआई लेवल 24 में जोड़ा गया

गड़बड़ी फ़ंक्शन दिखाता है.

erfc : गणितीय पूरक गड़बड़ी फ़ंक्शन

float erfc(float v);
float2 erfc(float2 v);
float3 erfc(float3 v);
float4 erfc(float4 v);
half erfc(half v); एपीआई लेवल 24 में जोड़ा गया
half2 erfc(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 erfc(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 erfc(half4 v); एपीआई लेवल 24 में जोड़ा गया

कॉम्प्लीमेंट्री एरर फ़ंक्शन दिखाता है.

exp : e की किसी संख्या के साथ घात लगाना

float exp(float v);
float2 exp(float2 v);
float3 exp(float3 v);
float4 exp(float4 v);
half exp(half v); एपीआई लेवल 24 में जोड़ा गया
half2 exp(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 exp(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 exp(half4 v); एपीआई लेवल 24 में जोड़ा गया

e की घात v, यानी e ^ v दिखाता है.

native_exp() भी देखें.

exp10 : 10 को किसी संख्या से बढ़ाएं

float exp10(float v);
float2 exp10(float2 v);
float3 exp10(float3 v);
float4 exp10(float4 v);
half exp10(half v); एपीआई लेवल 24 में जोड़ा गया
half2 exp10(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 exp10(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 exp10(half4 v); एपीआई लेवल 24 में जोड़ा गया

10 को v की घात पर ले जाता है. जैसे, 10.f ^ v.

native_exp10() भी देखें.

exp2 : 2 को किसी संख्या से बढ़ाना

float exp2(float v);
float2 exp2(float2 v);
float3 exp2(float3 v);
float4 exp2(float4 v);
half exp2(half v); एपीआई लेवल 24 में जोड़ा गया
half2 exp2(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 exp2(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 exp2(half4 v); एपीआई लेवल 24 में जोड़ा गया

यह फ़ंक्शन, 2 की घात v, यानी 2.f ^ v दिखाता है.

native_exp2() भी देखें.

expm1 : e को किसी संख्या में से एक घटाकर घात में लगाया गया

float expm1(float v);
float2 expm1(float2 v);
float3 expm1(float3 v);
float4 expm1(float4 v);
half expm1(half v); एपीआई लेवल 24 में जोड़ा गया
half2 expm1(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 expm1(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 expm1(half4 v); एपीआई लेवल 24 में जोड़ा गया

यह फ़ंक्शन, e की घात v में से 1 घटाकर दिखाता है. जैसे, (e ^ v) - 1.

native_expm1() भी देखें.

fabs : फ़्लोट की एब्सोल्यूट वैल्यू

float fabs(float v);
float2 fabs(float2 v);
float3 fabs(float3 v);
float4 fabs(float4 v);
half fabs(half v); एपीआई लेवल 24 में जोड़ा गया
half2 fabs(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 fabs(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 fabs(half4 v); एपीआई लेवल 24 में जोड़ा गया

यह फ़्लोट वैल्यू v की ऐब्सलूट वैल्यू दिखाता है.

पूर्णांकों के लिए, abs() का इस्तेमाल करें.

fdim : दो वैल्यू के बीच का पॉज़िटिव अंतर

float fdim(float a, float b);
float2 fdim(float2 a, float2 b);
float3 fdim(float3 a, float3 b);
float4 fdim(float4 a, float4 b);
half fdim(half a, half b); एपीआई लेवल 24 में जोड़ा गया
half2 fdim(half2 a, half2 b); एपीआई लेवल 24 में जोड़ा गया
half3 fdim(half3 a, half3 b); एपीआई लेवल 24 में जोड़ा गया
half4 fdim(half4 a, half4 b); एपीआई लेवल 24 में जोड़ा गया

दो वैल्यू के बीच का पॉज़िटिव अंतर दिखाता है.

अगर a > b है, तो (a - b) दिखाता है. अगर ऐसा नहीं है, तो 0f दिखाता है.

floor : सबसे छोटा पूर्णांक, जो किसी वैल्यू से ज़्यादा न हो

float floor(float v);
float2 floor(float2 v);
float3 floor(float3 v);
float4 floor(float4 v);
half floor(half v); एपीआई लेवल 24 में जोड़ा गया
half2 floor(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 floor(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 floor(half4 v); एपीआई लेवल 24 में जोड़ा गया

किसी वैल्यू से ज़्यादा न होने वाला सबसे छोटा पूर्णांक दिखाता है.

उदाहरण के लिए, floor(1.2f) से 1.f और floor(-1.2f) से -2.f मिलता है.

ceil() फ़ंक्शन के बारे में भी जानें.

fma : गुणा और जोड़ें

float fma(float multiplicand1, float multiplicand2, float offset);
float2 fma(float2 multiplicand1, float2 multiplicand2, float2 offset);
float3 fma(float3 multiplicand1, float3 multiplicand2, float3 offset);
float4 fma(float4 multiplicand1, float4 multiplicand2, float4 offset);
half fma(half multiplicand1, half multiplicand2, half offset); एपीआई लेवल 24 में जोड़ा गया
half2 fma(half2 multiplicand1, half2 multiplicand2, half2 offset); एपीआई लेवल 24 में जोड़ा गया
half3 fma(half3 multiplicand1, half3 multiplicand2, half3 offset); एपीआई लेवल 24 में जोड़ा गया
half4 fma(half4 multiplicand1, half4 multiplicand2, half4 offset); एपीआई लेवल 24 में जोड़ा गया

गुणा और जोड़ें. (multiplicand1 * multiplicand2) + offset दिखाता है.

यह फ़ंक्शन, mad() जैसा ही है. fma() में, गुणा करने पर मिलने वाले नतीजे को पूरी सटीकता के साथ सेव किया जाता है और जोड़ने के बाद ही उसे राउंड किया जाता है. mad() फ़ंक्शन, गुणा और जोड़ने के बाद राउंड करता है. rs_fp_relaxed मोड में, इस अतिरिक्त सटीक जानकारी की गारंटी नहीं दी जा सकती.

fmax : ज़्यादा से ज़्यादा दो फ़्लोट

float fmax(float a, float b);
float2 fmax(float2 a, float b);
float2 fmax(float2 a, float2 b);
float3 fmax(float3 a, float b);
float3 fmax(float3 a, float3 b);
float4 fmax(float4 a, float b);
float4 fmax(float4 a, float4 b);
half fmax(half a, half b); एपीआई लेवल 24 में जोड़ा गया
half2 fmax(half2 a, half b); एपीआई लेवल 24 में जोड़ा गया
half2 fmax(half2 a, half2 b); एपीआई लेवल 24 में जोड़ा गया
half3 fmax(half3 a, half b); एपीआई लेवल 24 में जोड़ा गया
half3 fmax(half3 a, half3 b); एपीआई लेवल 24 में जोड़ा गया
half4 fmax(half4 a, half b); एपीआई लेवल 24 में जोड़ा गया
half4 fmax(half4 a, half4 b); एपीआई लेवल 24 में जोड़ा गया

a और b में से सबसे बड़ी वैल्यू दिखाता है, यानी (a < b ? b : a).

max() फ़ंक्शन से मिलते-जुलते नतीजे मिलते हैं. हालांकि, इसे ज़्यादा डेटा टाइप पर लागू किया जा सकता है.

fmin : कम से कम दो फ़्लोट

float fmin(float a, float b);
float2 fmin(float2 a, float b);
float2 fmin(float2 a, float2 b);
float3 fmin(float3 a, float b);
float3 fmin(float3 a, float3 b);
float4 fmin(float4 a, float b);
float4 fmin(float4 a, float4 b);
half fmin(half a, half b); एपीआई लेवल 24 में जोड़ा गया
half2 fmin(half2 a, half b); एपीआई लेवल 24 में जोड़ा गया
half2 fmin(half2 a, half2 b); एपीआई लेवल 24 में जोड़ा गया
half3 fmin(half3 a, half b); एपीआई लेवल 24 में जोड़ा गया
half3 fmin(half3 a, half3 b); एपीआई लेवल 24 में जोड़ा गया
half4 fmin(half4 a, half b); एपीआई लेवल 24 में जोड़ा गया
half4 fmin(half4 a, half4 b); एपीआई लेवल 24 में जोड़ा गया

a और b में से सबसे छोटी वैल्यू दिखाता है. जैसे, (a > b ? b : a).

min() फ़ंक्शन, एक जैसे नतीजे दिखाता है. हालांकि, इसे ज़्यादा डेटा टाइप पर लागू किया जा सकता है.

fmod : मॉड्यूलो

float fmod(float numerator, float denominator);
float2 fmod(float2 numerator, float2 denominator);
float3 fmod(float3 numerator, float3 denominator);
float4 fmod(float4 numerator, float4 denominator);
half fmod(half numerator, half denominator); एपीआई लेवल 24 में जोड़ा गया
half2 fmod(half2 numerator, half2 denominator); एपीआई लेवल 24 में जोड़ा गया
half3 fmod(half3 numerator, half3 denominator); एपीआई लेवल 24 में जोड़ा गया
half4 fmod(half4 numerator, half4 denominator); एपीआई लेवल 24 में जोड़ा गया

(नंबरेटर / डेनोमिनेटर) का शेषफल दिखाता है. इसमें भागफल को शून्य के करीब राउंड किया जाता है.

remainder() फ़ंक्शन भी इसी तरह का है, लेकिन यह सबसे नज़दीक पूर्णांक के हिसाब से राउंड करता है. उदाहरण के लिए, fmod(-3.8f, 2.f) से -1.8f (-3.8f - -1.f * 2.f) का नतीजा मिलता है, जबकि remainder(-3.8f, 2.f) से 0.2f (-3.8f - -2.f * 2.f) का नतीजा मिलता है.

fract : फ़्रैक्शन का पॉज़िटिव हिस्सा

float fract(float v);
float fract(float v, float* floor);
float2 fract(float2 v);
float2 fract(float2 v, float2* floor);
float3 fract(float3 v);
float3 fract(float3 v, float3* floor);
float4 fract(float4 v);
float4 fract(float4 v, float4* floor);
half fract(half v); एपीआई लेवल 24 में जोड़ा गया
half fract(half v, half* floor); एपीआई लेवल 24 में जोड़ा गया
half2 fract(half2 v); एपीआई लेवल 24 में जोड़ा गया
half2 fract(half2 v, half2* floor); एपीआई लेवल 24 में जोड़ा गया
half3 fract(half3 v); एपीआई लेवल 24 में जोड़ा गया
half3 fract(half3 v, half3* floor); एपीआई लेवल 24 में जोड़ा गया
half4 fract(half4 v); एपीआई लेवल 24 में जोड़ा गया
half4 fract(half4 v, half4* floor); एपीआई लेवल 24 में जोड़ा गया
पैरामीटर
vइनपुट वैल्यू.
मंज़िलअगर फ़्लोर शून्य नहीं है, तो *फ़्लोर को v के फ़्लोर पर सेट किया जाएगा.

v के फ़्रैक्शनल हिस्से को दिखाता है, जैसे कि v - floor(v).

उदाहरण के लिए, fract(1.3f, &val) से 0.3f मिलता है और val को 1.f पर सेट करता है. fract(-1.3f, &val), 0.7f दिखाता है और val को -2.f पर सेट करता है.

frexp : बाइनरी मैन्टिसा और एक्सपोनेंट

float frexp(float v, int* exponent);
float2 frexp(float2 v, int2* exponent);
float3 frexp(float3 v, int3* exponent);
float4 frexp(float4 v, int4* exponent);
half frexp(half v, int* exponent); एपीआई लेवल 24 में जोड़ा गया
half2 frexp(half2 v, int2* exponent); एपीआई लेवल 24 में जोड़ा गया
half3 frexp(half3 v, int3* exponent); एपीआई लेवल 24 में जोड़ा गया
half4 frexp(half4 v, int4* exponent); एपीआई लेवल 24 में जोड़ा गया
पैरामीटर
vइनपुट वैल्यू.
घातांकअगर एक्सपोनेंट शून्य नहीं है, तो *exponent को v के एक्सपोनेंट पर सेट किया जाएगा.

v का बाइनरी मैन्टीसा और एक्सपोनेंट दिखाता है, यानी v == mantissa * 2 ^ exponent.

मैन्टिसा हमेशा 0.5 (शामिल) और 1.0 (शामिल नहीं) के बीच होता है.

इसके उलट ऑपरेशन के लिए, ldexp() देखें. logb() और ilogb() फ़ंक्शन के बारे में भी जानें.

half_recip : 16 बिट की सटीक वैल्यू के हिसाब से, संख्या का व्युत्क्रम

float half_recip(float v); एपीआई लेवल 17 में जोड़ा गया
float2 half_recip(float2 v); एपीआई लेवल 17 में जोड़ा गया
float3 half_recip(float3 v); एपीआई लेवल 17 में जोड़ा गया
float4 half_recip(float4 v); एपीआई लेवल 17 में जोड़ा गया

किसी वैल्यू का अनुमानित उलटा दिखाता है.

सटीक वैल्यू, 16 बिट की फ़्लोटिंग-पॉइंट वैल्यू होती है.

native_recip() भी देखें.

half_rsqrt : वर्गमूल का व्युत्क्रम, जिसे 16 बिट की सटीक जानकारी के हिसाब से कैलकुलेट किया जाता है

float half_rsqrt(float v); एपीआई लेवल 17 में जोड़ा गया
float2 half_rsqrt(float2 v); एपीआई लेवल 17 में जोड़ा गया
float3 half_rsqrt(float3 v); एपीआई लेवल 17 में जोड़ा गया
float4 half_rsqrt(float4 v); एपीआई लेवल 17 में जोड़ा गया

(1.f / sqrt(value)) की अनुमानित वैल्यू दिखाता है.

सटीक वैल्यू, 16 बिट की फ़्लोटिंग-पॉइंट वैल्यू होती है.

rsqrt(), native_rsqrt() भी देखें.

half_sqrt : 16 बिट की सटीक जानकारी के हिसाब से वर्गमूल का हिसाब लगाया जाता है

float half_sqrt(float v); एपीआई लेवल 17 में जोड़ा गया
float2 half_sqrt(float2 v); एपीआई लेवल 17 में जोड़ा गया
float3 half_sqrt(float3 v); एपीआई लेवल 17 में जोड़ा गया
float4 half_sqrt(float4 v); एपीआई लेवल 17 में जोड़ा गया

किसी वैल्यू का अनुमानित स्क्वेयर रूट दिखाता है.

सटीक वैल्यू, 16 बिट की फ़्लोटिंग-पॉइंट वैल्यू होती है.

sqrt(), native_sqrt() भी देखें.

hypot : हाइपोटेन्यूज़

float hypot(float a, float b);
float2 hypot(float2 a, float2 b);
float3 hypot(float3 a, float3 b);
float4 hypot(float4 a, float4 b);
half hypot(half a, half b); एपीआई लेवल 24 में जोड़ा गया
half2 hypot(half2 a, half2 b); एपीआई लेवल 24 में जोड़ा गया
half3 hypot(half3 a, half3 b); एपीआई लेवल 24 में जोड़ा गया
half4 hypot(half4 a, half4 b); एपीआई लेवल 24 में जोड़ा गया

हाइपोटेन्यूज़, यानी sqrt(a * a + b * b) दिखाता है.

native_hypot() भी देखें.

ilogb : दो के आधार पर एक्सपोनेंट

int ilogb(float v);
int ilogb(half v); एपीआई लेवल 24 में जोड़ा गया
int2 ilogb(float2 v);
int2 ilogb(half2 v); एपीआई लेवल 24 में जोड़ा गया
int3 ilogb(float3 v);
int3 ilogb(half3 v); एपीआई लेवल 24 में जोड़ा गया
int4 ilogb(float4 v);
int4 ilogb(half4 v); एपीआई लेवल 24 में जोड़ा गया

किसी वैल्यू का बेस दो एक्सपोनेंट दिखाता है. इसमें मैनटिसा, 1.f (शामिल) और 2.f (शामिल नहीं) के बीच होता है.

उदाहरण के लिए, ilogb(8.5f) से, नतीजे के तौर पर 3 मिलता है.

मैनटिसा में अंतर की वजह से, यह संख्या frexp() फ़ंक्शन से मिलने वाली संख्या से एक कम होती है.

logb() फ़ंक्शन भी इसी तरह का है, लेकिन यह फ़्लोट वैल्यू दिखाता है.

ldexp : मैनटिसा और एक्सपोनेंट से फ़्लोटिंग पॉइंट बनाता है

float ldexp(float mantissa, int exponent);
float2 ldexp(float2 mantissa, int exponent);
float2 ldexp(float2 mantissa, int2 exponent);
float3 ldexp(float3 mantissa, int exponent);
float3 ldexp(float3 mantissa, int3 exponent);
float4 ldexp(float4 mantissa, int exponent);
float4 ldexp(float4 mantissa, int4 exponent);
half ldexp(half mantissa, int exponent); एपीआई लेवल 24 में जोड़ा गया
half2 ldexp(half2 mantissa, int exponent); एपीआई लेवल 24 में जोड़ा गया
half2 ldexp(half2 mantissa, int2 exponent); एपीआई लेवल 24 में जोड़ा गया
half3 ldexp(half3 mantissa, int exponent); एपीआई लेवल 24 में जोड़ा गया
half3 ldexp(half3 mantissa, int3 exponent); एपीआई लेवल 24 में जोड़ा गया
half4 ldexp(half4 mantissa, int exponent); एपीआई लेवल 24 में जोड़ा गया
half4 ldexp(half4 mantissa, int4 exponent); एपीआई लेवल 24 में जोड़ा गया
पैरामीटर
मैनटिसामैनटिसा.
घातांकएक्सपोनेंट, एक कॉम्पोनेंट या मैच करने वाला वेक्टर.

यह मैन्टिसा और एक्सपोनेंट से बनाया गया फ़्लोटिंग पॉइंट दिखाता है, यानी (मैन्टिसा * 2 ^ एक्सपोनेंट).

इसके उलट ऑपरेशन के लिए, frexp() देखें.

lgamma : गामा फ़ंक्शन का नैचुरल लॉगारिद्म

float lgamma(float v);
float lgamma(float v, int* sign_of_gamma);
float2 lgamma(float2 v);
float2 lgamma(float2 v, int2* sign_of_gamma);
float3 lgamma(float3 v);
float3 lgamma(float3 v, int3* sign_of_gamma);
float4 lgamma(float4 v);
float4 lgamma(float4 v, int4* sign_of_gamma);
half lgamma(half v); एपीआई लेवल 24 में जोड़ा गया
half lgamma(half v, int* sign_of_gamma); एपीआई लेवल 24 में जोड़ा गया
half2 lgamma(half2 v); एपीआई लेवल 24 में जोड़ा गया
half2 lgamma(half2 v, int2* sign_of_gamma); एपीआई लेवल 24 में जोड़ा गया
half3 lgamma(half3 v); एपीआई लेवल 24 में जोड़ा गया
half3 lgamma(half3 v, int3* sign_of_gamma); एपीआई लेवल 24 में जोड़ा गया
half4 lgamma(half4 v); एपीआई लेवल 24 में जोड़ा गया
half4 lgamma(half4 v, int4* sign_of_gamma); एपीआई लेवल 24 में जोड़ा गया
पैरामीटर
v
sign_of_gammaअगर sign_of_gamma शून्य नहीं है, तो *sign_of_gamma को -1.f पर सेट किया जाएगा. ऐसा तब होगा, जब v का गामा नेगेटिव होगा. अगर गामा पॉज़िटिव होगा, तो *sign_of_gamma को 1.f पर सेट किया जाएगा.

गामा फ़ंक्शन की ऐब्सलूट वैल्यू, यानी log(fabs(tgamma(v))) का नेचुरल लॉगरिदम दिखाता है.

tgamma() फ़ंक्शन के बारे में भी जानें.

log : नैचुरल लॉगरिदम

float log(float v);
float2 log(float2 v);
float3 log(float3 v);
float4 log(float4 v);
half log(half v); एपीआई लेवल 24 में जोड़ा गया
half2 log(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 log(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 log(half4 v); एपीआई लेवल 24 में जोड़ा गया

नेचुरल लॉगारिद्म दिखाता है.

native_log() भी देखें.

log10 : 10 के आधार पर लॉगरिदम

float log10(float v);
float2 log10(float2 v);
float3 log10(float3 v);
float4 log10(float4 v);
half log10(half v); एपीआई लेवल 24 में जोड़ा गया
half2 log10(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 log10(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 log10(half4 v); एपीआई लेवल 24 में जोड़ा गया

बेस 10 का लॉगारिद्म दिखाता है.

native_log10() भी देखें.

log1p : किसी वैल्यू के नैचुरल लॉगारिद्म में 1 जोड़ना

float log1p(float v);
float2 log1p(float2 v);
float3 log1p(float3 v);
float4 log1p(float4 v);
half log1p(half v); एपीआई लेवल 24 में जोड़ा गया
half2 log1p(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 log1p(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 log1p(half4 v); एपीआई लेवल 24 में जोड़ा गया

(v + 1.f) का नेचुरल लॉगारिद्म दिखाता है.

native_log1p() भी देखें.

log2 : बेस 2 लॉगरिदम

float log2(float v);
float2 log2(float2 v);
float3 log2(float3 v);
float4 log2(float4 v);
half log2(half v); एपीआई लेवल 24 में जोड़ा गया
half2 log2(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 log2(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 log2(half4 v); एपीआई लेवल 24 में जोड़ा गया

बेस 2 का लॉगारिद्म दिखाता है.

native_log2() भी देखें.

logb : बेस दो एक्सपोनेंट

float logb(float v);
float2 logb(float2 v);
float3 logb(float3 v);
float4 logb(float4 v);
half logb(half v); एपीआई लेवल 24 में जोड़ा गया
half2 logb(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 logb(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 logb(half4 v); एपीआई लेवल 24 में जोड़ा गया

किसी वैल्यू के आधार दो एक्सपोनेंट को दिखाता है. इसमें मैन्टिसा, 1.f (शामिल) और 2.f (शामिल नहीं) के बीच होता है.

उदाहरण के लिए, logb(8.5f) से 3.f मिलता है.

मैनटिसा में अंतर की वजह से, यह संख्या frexp() फ़ंक्शन से मिली संख्या से एक कम होती है.

ilogb() फ़ंक्शन भी इसी तरह का है, लेकिन यह पूर्णांक दिखाता है.

mad : गुणा और जोड़ें

float mad(float multiplicand1, float multiplicand2, float offset);
float2 mad(float2 multiplicand1, float2 multiplicand2, float2 offset);
float3 mad(float3 multiplicand1, float3 multiplicand2, float3 offset);
float4 mad(float4 multiplicand1, float4 multiplicand2, float4 offset);
half mad(half multiplicand1, half multiplicand2, half offset); एपीआई लेवल 24 में जोड़ा गया
half2 mad(half2 multiplicand1, half2 multiplicand2, half2 offset); एपीआई लेवल 24 में जोड़ा गया
half3 mad(half3 multiplicand1, half3 multiplicand2, half3 offset); एपीआई लेवल 24 में जोड़ा गया
half4 mad(half4 multiplicand1, half4 multiplicand2, half4 offset); एपीआई लेवल 24 में जोड़ा गया

गुणा और जोड़ें. (multiplicand1 * multiplicand2) + offset दिखाता है.

यह फ़ंक्शन, fma() से मिलता-जुलता है. fma(), गुणा करने के नतीजे को पूरी सटीकता के साथ बनाए रखता है और जोड़ने के बाद ही उसे राउंड करता है. mad() फ़ंक्शन, गुणा और जोड़ के बाद राउंड करता है. rs_fp_relaxed मोड में, हो सकता है कि mad() फ़ंक्शन, गुणा करने के बाद राउंडिंग न करे.

max : ज़्यादा से ज़्यादा

char max(char a, char b);
char2 max(char2 a, char2 b);
char3 max(char3 a, char3 b);
char4 max(char4 a, char4 b);
float max(float a, float b);
float2 max(float2 a, float b);
float2 max(float2 a, float2 b);
float3 max(float3 a, float b);
float3 max(float3 a, float3 b);
float4 max(float4 a, float b);
float4 max(float4 a, float4 b);
half max(half a, half b); एपीआई लेवल 24 में जोड़ा गया
half2 max(half2 a, half b); एपीआई लेवल 24 में जोड़ा गया
half2 max(half2 a, half2 b); एपीआई लेवल 24 में जोड़ा गया
half3 max(half3 a, half b); एपीआई लेवल 24 में जोड़ा गया
half3 max(half3 a, half3 b); एपीआई लेवल 24 में जोड़ा गया
half4 max(half4 a, half b); एपीआई लेवल 24 में जोड़ा गया
half4 max(half4 a, half4 b); एपीआई लेवल 24 में जोड़ा गया
int max(int a, int b);
int2 max(int2 a, int2 b);
int3 max(int3 a, int3 b);
int4 max(int4 a, int4 b);
long max(long a, long b); एपीआई लेवल 21 में जोड़ा गया
long2 max(long2 a, long2 b); एपीआई लेवल 21 में जोड़ा गया
long3 max(long3 a, long3 b); एपीआई लेवल 21 में जोड़ा गया
long4 max(long4 a, long4 b); एपीआई लेवल 21 में जोड़ा गया
short max(short a, short b);
short2 max(short2 a, short2 b);
short3 max(short3 a, short3 b);
short4 max(short4 a, short4 b);
uchar max(uchar a, uchar b);
uchar2 max(uchar2 a, uchar2 b);
uchar3 max(uchar3 a, uchar3 b);
uchar4 max(uchar4 a, uchar4 b);
uint max(uint a, uint b);
uint2 max(uint2 a, uint2 b);
uint3 max(uint3 a, uint3 b);
uint4 max(uint4 a, uint4 b);
ulong max(ulong a, ulong b); एपीआई लेवल 21 में जोड़ा गया
ulong2 max(ulong2 a, ulong2 b); एपीआई लेवल 21 में जोड़ा गया
ulong3 max(ulong3 a, ulong3 b); एपीआई लेवल 21 में जोड़ा गया
ulong4 max(ulong4 a, ulong4 b); एपीआई लेवल 21 में जोड़ा गया
ushort max(ushort a, ushort b);
ushort2 max(ushort2 a, ushort2 b);
ushort3 max(ushort3 a, ushort3 b);
ushort4 max(ushort4 a, ushort4 b);

दो आर्ग्युमेंट में से सबसे बड़ी वैल्यू दिखाता है.

min : कम से कम

char min(char a, char b);
char2 min(char2 a, char2 b);
char3 min(char3 a, char3 b);
char4 min(char4 a, char4 b);
float min(float a, float b);
float2 min(float2 a, float b);
float2 min(float2 a, float2 b);
float3 min(float3 a, float b);
float3 min(float3 a, float3 b);
float4 min(float4 a, float b);
float4 min(float4 a, float4 b);
half min(half a, half b); एपीआई लेवल 24 में जोड़ा गया
half2 min(half2 a, half b); एपीआई लेवल 24 में जोड़ा गया
half2 min(half2 a, half2 b); एपीआई लेवल 24 में जोड़ा गया
half3 min(half3 a, half b); एपीआई लेवल 24 में जोड़ा गया
half3 min(half3 a, half3 b); एपीआई लेवल 24 में जोड़ा गया
half4 min(half4 a, half b); एपीआई लेवल 24 में जोड़ा गया
half4 min(half4 a, half4 b); एपीआई लेवल 24 में जोड़ा गया
int min(int a, int b);
int2 min(int2 a, int2 b);
int3 min(int3 a, int3 b);
int4 min(int4 a, int4 b);
long min(long a, long b); एपीआई लेवल 21 में जोड़ा गया
long2 min(long2 a, long2 b); एपीआई लेवल 21 में जोड़ा गया
long3 min(long3 a, long3 b); एपीआई लेवल 21 में जोड़ा गया
long4 min(long4 a, long4 b); एपीआई लेवल 21 में जोड़ा गया
short min(short a, short b);
short2 min(short2 a, short2 b);
short3 min(short3 a, short3 b);
short4 min(short4 a, short4 b);
uchar min(uchar a, uchar b);
uchar2 min(uchar2 a, uchar2 b);
uchar3 min(uchar3 a, uchar3 b);
uchar4 min(uchar4 a, uchar4 b);
uint min(uint a, uint b);
uint2 min(uint2 a, uint2 b);
uint3 min(uint3 a, uint3 b);
uint4 min(uint4 a, uint4 b);
ulong min(ulong a, ulong b); एपीआई लेवल 21 में जोड़ा गया
ulong2 min(ulong2 a, ulong2 b); एपीआई लेवल 21 में जोड़ा गया
ulong3 min(ulong3 a, ulong3 b); एपीआई लेवल 21 में जोड़ा गया
ulong4 min(ulong4 a, ulong4 b); एपीआई लेवल 21 में जोड़ा गया
ushort min(ushort a, ushort b);
ushort2 min(ushort2 a, ushort2 b);
ushort3 min(ushort3 a, ushort3 b);
ushort4 min(ushort4 a, ushort4 b);

दो आर्ग्युमेंट की सबसे कम वैल्यू दिखाता है.

mix : दो वैल्यू को मिक्स करता है

float mix(float start, float stop, float fraction);
float2 mix(float2 start, float2 stop, float fraction);
float2 mix(float2 start, float2 stop, float2 fraction);
float3 mix(float3 start, float3 stop, float fraction);
float3 mix(float3 start, float3 stop, float3 fraction);
float4 mix(float4 start, float4 stop, float fraction);
float4 mix(float4 start, float4 stop, float4 fraction);
half mix(half start, half stop, half fraction); एपीआई लेवल 24 में जोड़ा गया
half2 mix(half2 start, half2 stop, half fraction); एपीआई लेवल 24 में जोड़ा गया
half2 mix(half2 start, half2 stop, half2 fraction); एपीआई लेवल 24 में जोड़ा गया
half3 mix(half3 start, half3 stop, half fraction); एपीआई लेवल 24 में जोड़ा गया
half3 mix(half3 start, half3 stop, half3 fraction); एपीआई लेवल 24 में जोड़ा गया
half4 mix(half4 start, half4 stop, half fraction); एपीआई लेवल 24 में जोड़ा गया
half4 mix(half4 start, half4 stop, half4 fraction); एपीआई लेवल 24 में जोड़ा गया

यह फ़ंक्शन, start + ((stop - start) * fraction) दिखाता है.

इसका इस्तेमाल, दो वैल्यू को मिलाने के लिए किया जा सकता है. उदाहरण के लिए, 40% रंग1 और 60% रंग2 वाला नया रंग बनाने के लिए, mix(color1, color2, 0.6f) का इस्तेमाल करें.

modf : इंटिग्रल और फ़्रैक्शनल कॉम्पोनेंट

float modf(float v, float* integral_part);
float2 modf(float2 v, float2* integral_part);
float3 modf(float3 v, float3* integral_part);
float4 modf(float4 v, float4* integral_part);
half modf(half v, half* integral_part); एपीआई लेवल 24 में जोड़ा गया
half2 modf(half2 v, half2* integral_part); एपीआई लेवल 24 में जोड़ा गया
half3 modf(half3 v, half3* integral_part); एपीआई लेवल 24 में जोड़ा गया
half4 modf(half4 v, half4* integral_part); एपीआई लेवल 24 में जोड़ा गया
पैरामीटर
vसोर्स की वैल्यू.
integral_part*integral_part को संख्या के पूर्णांक हिस्से पर सेट किया जाएगा.
रिटर्न
वैल्यू का फ़्लोटिंग पॉइंट हिस्सा.

किसी संख्या के पूर्णांक और भिन्न वाले हिस्सों को दिखाता है.

दोनों कॉम्पोनेंट का साइन, x जैसा ही होगा. उदाहरण के लिए, -3.72f के इनपुट के लिए, *integral_part को -3.f पर सेट किया जाएगा और .72f दिखाया जाएगा.

nan : यह कोई संख्या नहीं है

float nan(uint v);
पैरामीटर
vइस्तेमाल नहीं किया जाता.

NaN वैल्यू (नॉट ए नंबर) दिखाता है.

nan_half : कोई संख्या नहीं है

आधा nan_half(); एपीआई लेवल 24 में जोड़ा गया

यह फ़ंक्शन, हफ़़्ट-प्रिसिशन फ़्लोटिंग पॉइंट NaN वैल्यू (नॉट अ नंबर) दिखाता है.

native_acos : अनुमानित इनवर्स कोसाइन

float native_acos(float v); एपीआई लेवल 21 में जोड़ा गया
float2 native_acos(float2 v); एपीआई लेवल 21 में जोड़ा गया
float3 native_acos(float3 v); एपीआई लेवल 21 में जोड़ा गया
float4 native_acos(float4 v); एपीआई लेवल 21 में जोड़ा गया
half native_acos(half v); एपीआई लेवल 24 में जोड़ा गया
half2 native_acos(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 native_acos(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 native_acos(half4 v); एपीआई लेवल 24 में जोड़ा गया

रेडियन में, कोसाइन के इनवर्स का अनुमानित मान दिखाता है.

यह फ़ंक्शन, -1 से कम या 1 से ज़्यादा इनपुट वैल्यू से कोई नतीजा नहीं दिखाता.

acos() फ़ंक्शन के बारे में भी जानें.

native_acosh : अनुमानित इन्वर्स हाइपरबोलिक कोसाइन

float native_acosh(float v); एपीआई लेवल 21 में जोड़ा गया
float2 native_acosh(float2 v); एपीआई लेवल 21 में जोड़ा गया
float3 native_acosh(float3 v); एपीआई लेवल 21 में जोड़ा गया
float4 native_acosh(float4 v); एपीआई लेवल 21 में जोड़ा गया
half native_acosh(half v); एपीआई लेवल 24 में जोड़ा गया
half2 native_acosh(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 native_acosh(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 native_acosh(half4 v); एपीआई लेवल 24 में जोड़ा गया

रेडियन में, इनवर्स हाइपरबोलिक कोसाइन का अनुमानित मान दिखाता है.

acosh() फ़ंक्शन के बारे में भी जानें.

native_acospi : अनुमानित इनवर्स कोसाइन को पाई से भाग दिया जाता है

float native_acospi(float v); एपीआई लेवल 21 में जोड़ा गया
float2 native_acospi(float2 v); एपीआई लेवल 21 में जोड़ा गया
float3 native_acospi(float3 v); एपीआई लेवल 21 में जोड़ा गया
float4 native_acospi(float4 v); एपीआई लेवल 21 में जोड़ा गया
half native_acospi(half v); एपीआई लेवल 24 में जोड़ा गया
half2 native_acospi(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 native_acospi(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 native_acospi(half4 v); एपीआई लेवल 24 में जोड़ा गया

रेडियन में इनवर्स कोसाइन का अनुमानित मान दिखाता है. इसके लिए, पाई से भाग दिया जाता है.

इनवर्स कोसाइन को डिग्री में मेज़र करने के लिए, acospi(a) * 180.f का इस्तेमाल करें.

यह फ़ंक्शन, -1 से कम या 1 से ज़्यादा इनपुट वैल्यू से कोई नतीजा नहीं दिखाता.

acospi() फ़ंक्शन के बारे में भी जानें.

native_asin : अनुमानित इनवर्स साइन

float native_asin(float v); एपीआई लेवल 21 में जोड़ा गया
float2 native_asin(float2 v); एपीआई लेवल 21 में जोड़ा गया
float3 native_asin(float3 v); एपीआई लेवल 21 में जोड़ा गया
float4 native_asin(float4 v); एपीआई लेवल 21 में जोड़ा गया
half native_asin(half v); एपीआई लेवल 24 में जोड़ा गया
half2 native_asin(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 native_asin(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 native_asin(half4 v); एपीआई लेवल 24 में जोड़ा गया

रेडियन में, साइन फ़ंक्शन के ऑपज़िट साइड की अनुमानित वैल्यू दिखाता है.

यह फ़ंक्शन, -1 से कम या 1 से ज़्यादा इनपुट वैल्यू से कोई नतीजा नहीं दिखाता.

asin() फ़ंक्शन के बारे में भी जानें.

native_asinh : अनुमानित इन्वर्स हाइपरबोलिक साइन

float native_asinh(float v); एपीआई लेवल 21 में जोड़ा गया
float2 native_asinh(float2 v); एपीआई लेवल 21 में जोड़ा गया
float3 native_asinh(float3 v); एपीआई लेवल 21 में जोड़ा गया
float4 native_asinh(float4 v); एपीआई लेवल 21 में जोड़ा गया
half native_asinh(half v); एपीआई लेवल 24 में जोड़ा गया
half2 native_asinh(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 native_asinh(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 native_asinh(half4 v); एपीआई लेवल 24 में जोड़ा गया

रेडियन में, इनवर्स हाइपरबोलिक साइन का अनुमानित मान दिखाता है.

asinh() फ़ंक्शन के बारे में भी जानें.

native_asinpi : अनुमानित इनवर्स साइन को पाई से भाग दिया जाता है

float native_asinpi(float v); एपीआई लेवल 21 में जोड़ा गया
float2 native_asinpi(float2 v); एपीआई लेवल 21 में जोड़ा गया
float3 native_asinpi(float3 v); एपीआई लेवल 21 में जोड़ा गया
float4 native_asinpi(float4 v); एपीआई लेवल 21 में जोड़ा गया
half native_asinpi(half v); एपीआई लेवल 24 में जोड़ा गया
half2 native_asinpi(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 native_asinpi(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 native_asinpi(half4 v); एपीआई लेवल 24 में जोड़ा गया

रेडियन में इनवर्स साइन का अनुमानित मान दिखाता है. इसमें पाई से भाग दिया जाता है.

डिग्री में मेज़र किए गए इनवर्स साइन का पता लगाने के लिए, asinpi(a) * 180.f का इस्तेमाल करें.

यह फ़ंक्शन, -1 से कम या 1 से ज़्यादा इनपुट वैल्यू से कोई नतीजा नहीं दिखाता.

asinpi() फ़ंक्शन के बारे में भी जानें.

native_atan : अनुमानित इनवर्स टेंगेंट

float native_atan(float v); एपीआई लेवल 21 में जोड़ा गया
float2 native_atan(float2 v); एपीआई लेवल 21 में जोड़ा गया
float3 native_atan(float3 v); एपीआई लेवल 21 में जोड़ा गया
float4 native_atan(float4 v); एपीआई लेवल 21 में जोड़ा गया
half native_atan(half v); एपीआई लेवल 24 में जोड़ा गया
half2 native_atan(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 native_atan(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 native_atan(half4 v); एपीआई लेवल 24 में जोड़ा गया

रेडियन में, इनवर्स टैंजेंट की अनुमानित वैल्यू दिखाता है.

atan() भी देखें.

native_atan2 : किसी अनुपात का अनुमानित इनवर्स टेंगेंट

float native_atan2(float numerator, float denominator); एपीआई लेवल 21 में जोड़ा गया
float2 native_atan2(float2 numerator, float2 denominator); एपीआई लेवल 21 में जोड़ा गया
float3 native_atan2(float3 numerator, float3 denominator); एपीआई लेवल 21 में जोड़ा गया
float4 native_atan2(float4 numerator, float4 denominator); एपीआई लेवल 21 में जोड़ा गया
half native_atan2(half numerator, half denominator); एपीआई लेवल 24 में जोड़ा गया
half2 native_atan2(half2 numerator, half2 denominator); एपीआई लेवल 24 में जोड़ा गया
half3 native_atan2(half3 numerator, half3 denominator); एपीआई लेवल 24 में जोड़ा गया
half4 native_atan2(half4 numerator, half4 denominator); एपीआई लेवल 24 में जोड़ा गया
पैरामीटर
न्यूमरेटरअंश (न्यूमरेटर).
डिनोमिनेटरडिनोमिनेटर. यह 0 हो सकता है.

रेडियन में, (numerator / denominator) के इनवर्स टैंजेंट का अनुमानित मान दिखाता है.

atan2() फ़ंक्शन के बारे में भी जानें.

native_atan2pi : किसी अनुपात के इनवर्स टेंगेंट का अनुमानित मान, जिसे पाई से भाग दिया गया है

float native_atan2pi(float numerator, float denominator); एपीआई लेवल 21 में जोड़ा गया
float2 native_atan2pi(float2 numerator, float2 denominator); एपीआई लेवल 21 में जोड़ा गया
float3 native_atan2pi(float3 numerator, float3 denominator); एपीआई लेवल 21 में जोड़ा गया
float4 native_atan2pi(float4 numerator, float4 denominator); एपीआई लेवल 21 में जोड़ा गया
half native_atan2pi(half numerator, half denominator); एपीआई लेवल 24 में जोड़ा गया
half2 native_atan2pi(half2 numerator, half2 denominator); एपीआई लेवल 24 में जोड़ा गया
half3 native_atan2pi(half3 numerator, half3 denominator); एपीआई लेवल 24 में जोड़ा गया
half4 native_atan2pi(half4 numerator, half4 denominator); एपीआई लेवल 24 में जोड़ा गया
पैरामीटर
न्यूमरेटरअंश (न्यूमरेटर).
डिनोमिनेटरडिनोमिनेटर. यह 0 हो सकता है.

रेडियन में (numerator / denominator) के इनवर्स टैंजेंट का अनुमानित वैल्यू दिखाता है. इसके लिए, (numerator / denominator) को पाई से भाग दिया जाता है.

डिग्री में मेज़र किया गया इनवर्स टेंगेंट पाने के लिए, atan2pi(n, d) * 180.f का इस्तेमाल करें.

atan2pi() फ़ंक्शन के बारे में भी जानें.

native_atanh : अनुमानित इन्वर्स हाइपरबोलिक टेंगेंट

float native_atanh(float v); एपीआई लेवल 21 में जोड़ा गया
float2 native_atanh(float2 v); एपीआई लेवल 21 में जोड़ा गया
float3 native_atanh(float3 v); एपीआई लेवल 21 में जोड़ा गया
float4 native_atanh(float4 v); एपीआई लेवल 21 में जोड़ा गया
half native_atanh(half v); एपीआई लेवल 24 में जोड़ा गया
half2 native_atanh(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 native_atanh(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 native_atanh(half4 v); एपीआई लेवल 24 में जोड़ा गया

रेडियन में, इनवर्स हाइपरबोलिक टैंजेंट का अनुमानित मान दिखाता है.

atanh() फ़ंक्शन के बारे में भी जानें.

native_atanpi : अनुमानित इनवर्स टेंगेंट को पाई से भागा जाता है

float native_atanpi(float v); एपीआई लेवल 21 में जोड़ा गया
float2 native_atanpi(float2 v); एपीआई लेवल 21 में जोड़ा गया
float3 native_atanpi(float3 v); एपीआई लेवल 21 में जोड़ा गया
float4 native_atanpi(float4 v); एपीआई लेवल 21 में जोड़ा गया
half native_atanpi(half v); एपीआई लेवल 24 में जोड़ा गया
half2 native_atanpi(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 native_atanpi(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 native_atanpi(half4 v); एपीआई लेवल 24 में जोड़ा गया

रेडियन में, इनवर्स टैंजेंट का अनुमानित मान दिखाता है. इसमें पाई से भाग दिया जाता है.

डिग्री में मेज़र किया गया इनवर्स टेंगेंट पाने के लिए, atanpi(a) * 180.f का इस्तेमाल करें.

atanpi() फ़ंक्शन के बारे में भी जानें.

native_cbrt : घन रूट का अनुमान

float native_cbrt(float v); एपीआई लेवल 21 में जोड़ा गया
float2 native_cbrt(float2 v); एपीआई लेवल 21 में जोड़ा गया
float3 native_cbrt(float3 v); एपीआई लेवल 21 में जोड़ा गया
float4 native_cbrt(float4 v); एपीआई लेवल 21 में जोड़ा गया
half native_cbrt(half v); एपीआई लेवल 24 में जोड़ा गया
half2 native_cbrt(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 native_cbrt(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 native_cbrt(half4 v); एपीआई लेवल 24 में जोड़ा गया

किसी संख्या का अनुमानित घन रूट दिखाता है.

cbrt() फ़ंक्शन के बारे में भी जानें.

native_cos : अनुमानित कोसाइन

float native_cos(float v); एपीआई लेवल 21 में जोड़ा गया
float2 native_cos(float2 v); एपीआई लेवल 21 में जोड़ा गया
float3 native_cos(float3 v); एपीआई लेवल 21 में जोड़ा गया
float4 native_cos(float4 v); एपीआई लेवल 21 में जोड़ा गया
half native_cos(half v); एपीआई लेवल 24 में जोड़ा गया
half2 native_cos(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 native_cos(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 native_cos(half4 v); एपीआई लेवल 24 में जोड़ा गया

रेडियन में मापे गए किसी कोण का अनुमानित कोसाइन दिखाता है.

cos() फ़ंक्शन के बारे में भी जानें.

native_cosh : अनुमानित हाइपरबोलिक कोसाइन

float native_cosh(float v); एपीआई लेवल 21 में जोड़ा गया
float2 native_cosh(float2 v); एपीआई लेवल 21 में जोड़ा गया
float3 native_cosh(float3 v); एपीआई लेवल 21 में जोड़ा गया
float4 native_cosh(float4 v); एपीआई लेवल 21 में जोड़ा गया
half native_cosh(half v); एपीआई लेवल 24 में जोड़ा गया
half2 native_cosh(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 native_cosh(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 native_cosh(half4 v); एपीआई लेवल 24 में जोड़ा गया

हाइपरबोलिक कोसाइन का अनुमानित मान दिखाता है.

cosh() फ़ंक्शन के बारे में भी जानें.

native_cospi : किसी संख्या को पाई से गुणा करने पर, उसके कोसाइन का अनुमानित मान

float native_cospi(float v); एपीआई लेवल 21 में जोड़ा गया
float2 native_cospi(float2 v); एपीआई लेवल 21 में जोड़ा गया
float3 native_cospi(float3 v); एपीआई लेवल 21 में जोड़ा गया
float4 native_cospi(float4 v); एपीआई लेवल 21 में जोड़ा गया
half native_cospi(half v); एपीआई लेवल 24 में जोड़ा गया
half2 native_cospi(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 native_cospi(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 native_cospi(half4 v); एपीआई लेवल 24 में जोड़ा गया

(v * pi) का अनुमानित कोसाइन दिखाता है. (v * pi) को रेडियन में मेज़र किया जाता है.

डिग्री में मेज़र की गई वैल्यू का कोसाइन पाने के लिए, cospi(v / 180.f) को कॉल करें.

cospi() फ़ंक्शन के बारे में भी जानें.

native_divide : अनुमानित भाग

float native_divide(float left_vector, float right_vector); एपीआई लेवल 21 में जोड़ा गया
float2 native_divide(float2 left_vector, float2 right_vector); एपीआई लेवल 21 में जोड़ा गया
float3 native_divide(float3 left_vector, float3 right_vector); एपीआई लेवल 21 में जोड़ा गया
float4 native_divide(float4 left_vector, float4 right_vector); एपीआई लेवल 21 में जोड़ा गया
half native_divide(half left_vector, half right_vector); एपीआई लेवल 24 में जोड़ा गया
half2 native_divide(half2 left_vector, half2 right_vector); एपीआई लेवल 24 में जोड़ा गया
half3 native_divide(half3 left_vector, half3 right_vector); एपीआई लेवल 24 में जोड़ा गया
half4 native_divide(half4 left_vector, half4 right_vector); एपीआई लेवल 24 में जोड़ा गया

दो वैल्यू के बीच के अनुमानित अंतर का हिसाब लगाता है.

native_exp : किसी संख्या के साथ e का अनुमानित घातांक

float native_exp(float v); एपीआई लेवल 18 में जोड़ा गया
float2 native_exp(float2 v); एपीआई लेवल 18 में जोड़ा गया
float3 native_exp(float3 v); एपीआई लेवल 18 में जोड़ा गया
float4 native_exp(float4 v); एपीआई लेवल 18 में जोड़ा गया
half native_exp(half v); एपीआई लेवल 24 में जोड़ा गया
half2 native_exp(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 native_exp(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 native_exp(half4 v); एपीआई लेवल 24 में जोड़ा गया

अनुमानित समय

यह -86.f से 86.f तक के इनपुट के लिए मान्य है. सटीक वैल्यू, 16 बिट फ़्लोटिंग पॉइंट वैल्यू का इस्तेमाल करने से मिलने वाली वैल्यू से कम नहीं है.

exp() फ़ंक्शन के बारे में भी जानें.

native_exp10 : 10 को किसी संख्या से ऊपर उठाने का अनुमान

float native_exp10(float v); एपीआई लेवल 18 में जोड़ा गया
float2 native_exp10(float2 v); एपीआई लेवल 18 में जोड़ा गया
float3 native_exp10(float3 v); एपीआई लेवल 18 में जोड़ा गया
float4 native_exp10(float4 v); एपीआई लेवल 18 में जोड़ा गया
half native_exp10(half v); एपीआई लेवल 24 में जोड़ा गया
half2 native_exp10(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 native_exp10(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 native_exp10(half4 v); एपीआई लेवल 24 में जोड़ा गया

तेज़ी से अनुमानित exp10.

यह -37.f से 37.f तक के इनपुट के लिए मान्य है. सटीक वैल्यू, 16 बिट फ़्लोटिंग पॉइंट वैल्यू का इस्तेमाल करने से मिलने वाली वैल्यू से कम नहीं है.

exp10() फ़ंक्शन के बारे में भी जानें.

native_exp2 : किसी संख्या को 2 की घात में बढ़ाने का अनुमान

float native_exp2(float v); एपीआई लेवल 18 में जोड़ा गया
float2 native_exp2(float2 v); एपीआई लेवल 18 में जोड़ा गया
float3 native_exp2(float3 v); एपीआई लेवल 18 में जोड़ा गया
float4 native_exp2(float4 v); एपीआई लेवल 18 में जोड़ा गया
half native_exp2(half v); एपीआई लेवल 24 में जोड़ा गया
half2 native_exp2(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 native_exp2(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 native_exp2(half4 v); एपीआई लेवल 24 में जोड़ा गया

फ़ास्ट अप्रोक्सिमेट एक्सपी2.

यह -125.f से 125.f तक के इनपुट के लिए मान्य है. सटीक वैल्यू, 16 बिट फ़्लोटिंग पॉइंट वैल्यू का इस्तेमाल करने से मिलने वाली वैल्यू से कम नहीं है.

exp2() फ़ंक्शन के बारे में भी जानें.

native_expm1 : किसी संख्या में एक को घटाने के बाद, e को उसके घात में ले जाने पर, करीब-करीब कितना होगा

float native_expm1(float v); एपीआई लेवल 21 में जोड़ा गया
float2 native_expm1(float2 v); एपीआई लेवल 21 में जोड़ा गया
float3 native_expm1(float3 v); एपीआई लेवल 21 में जोड़ा गया
float4 native_expm1(float4 v); एपीआई लेवल 21 में जोड़ा गया
half native_expm1(half v); एपीआई लेवल 24 में जोड़ा गया
half2 native_expm1(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 native_expm1(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 native_expm1(half4 v); एपीआई लेवल 24 में जोड़ा गया

यह फ़ंक्शन, (e ^ v) - 1 की अनुमानित वैल्यू दिखाता है.

expm1() फ़ंक्शन के बारे में भी जानें.

native_hypot : हाइपोटेनस का अनुमानित मान

float native_hypot(float a, float b); एपीआई लेवल 21 में जोड़ा गया
float2 native_hypot(float2 a, float2 b); एपीआई लेवल 21 में जोड़ा गया
float3 native_hypot(float3 a, float3 b); एपीआई लेवल 21 में जोड़ा गया
float4 native_hypot(float4 a, float4 b); एपीआई लेवल 21 में जोड़ा गया
half native_hypot(half a, half b); एपीआई लेवल 24 में जोड़ा गया
half2 native_hypot(half2 a, half2 b); एपीआई लेवल 24 में जोड़ा गया
half3 native_hypot(half3 a, half3 b); एपीआई लेवल 24 में जोड़ा गया
half4 native_hypot(half4 a, half4 b); एपीआई लेवल 24 में जोड़ा गया

native_sqrt(a * a + b * b) का अनुमानित वैल्यू दिखाता है

hypot() फ़ंक्शन के बारे में भी जानें.

native_log : नैचुरल लॉगरिदम का अनुमान

float native_log(float v); एपीआई लेवल 18 में जोड़ा गया
float2 native_log(float2 v); एपीआई लेवल 18 में जोड़ा गया
float3 native_log(float3 v); एपीआई लेवल 18 में जोड़ा गया
float4 native_log(float4 v); एपीआई लेवल 18 में जोड़ा गया
half native_log(half v); एपीआई लेवल 24 में जोड़ा गया
half2 native_log(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 native_log(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 native_log(half4 v); एपीआई लेवल 24 में जोड़ा गया

अनुमानित लॉग तेज़ी से जनरेट होता है.

यह शून्य के बहुत करीब की वैल्यू के लिए सटीक नहीं है.

log() भी देखें.

native_log10 : आधार 10 का अनुमानित लॉगरिदम

float native_log10(float v); एपीआई लेवल 18 में जोड़ा गया
float2 native_log10(float2 v); एपीआई लेवल 18 में जोड़ा गया
float3 native_log10(float3 v); एपीआई लेवल 18 में जोड़ा गया
float4 native_log10(float4 v); एपीआई लेवल 18 में जोड़ा गया
half native_log10(half v); एपीआई लेवल 24 में जोड़ा गया
half2 native_log10(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 native_log10(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 native_log10(half4 v); एपीआई लेवल 24 में जोड़ा गया

तेज़ी से अनुमानित log10.

यह शून्य के बहुत करीब की वैल्यू के लिए सटीक नहीं है.

log10() फ़ंक्शन के बारे में भी जानें.

native_log1p : किसी वैल्यू के नैचुरल लॉगारिद्म (सामान्य लघुगणक) के साथ 1 जोड़ने पर मिलने वाला अनुमानित नतीजा

float native_log1p(float v); एपीआई लेवल 21 में जोड़ा गया
float2 native_log1p(float2 v); एपीआई लेवल 21 में जोड़ा गया
float3 native_log1p(float3 v); एपीआई लेवल 21 में जोड़ा गया
float4 native_log1p(float4 v); एपीआई लेवल 21 में जोड़ा गया
half native_log1p(half v); एपीआई लेवल 24 में जोड़ा गया
half2 native_log1p(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 native_log1p(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 native_log1p(half4 v); एपीआई लेवल 24 में जोड़ा गया

(v + 1.0f) का अनुमानित नेचुरल लॉगारिद्म दिखाता है

log1p() भी देखें.

native_log2 : आधार 2 का अनुमानित लॉगारिद्म

float native_log2(float v); एपीआई लेवल 18 में जोड़ा गया
float2 native_log2(float2 v); एपीआई लेवल 18 में जोड़ा गया
float3 native_log2(float3 v); एपीआई लेवल 18 में जोड़ा गया
float4 native_log2(float4 v); एपीआई लेवल 18 में जोड़ा गया
half native_log2(half v); एपीआई लेवल 24 में जोड़ा गया
half2 native_log2(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 native_log2(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 native_log2(half4 v); एपीआई लेवल 24 में जोड़ा गया

लॉग2 का अनुमानित फ़ंक्शन तेज़ी से लागू करता है.

यह शून्य के बहुत करीब की वैल्यू के लिए सटीक नहीं है.

log2() फ़ंक्शन के बारे में भी जानें.

native_powr : किसी अनुमानित पॉज़िटिव बेस को घातांक में बढ़ाया गया

float native_powr(float base, float exponent); एपीआई लेवल 18 में जोड़ा गया
float2 native_powr(float2 base, float2 exponent); एपीआई लेवल 18 में जोड़ा गया
float3 native_powr(float3 base, float3 exponent); एपीआई लेवल 18 में जोड़ा गया
float4 native_powr(float4 base, float4 exponent); एपीआई लेवल 18 में जोड़ा गया
half native_powr(half base, half exponent); एपीआई लेवल 24 में जोड़ा गया
half2 native_powr(half2 base, half2 exponent); एपीआई लेवल 24 में जोड़ा गया
half3 native_powr(half3 base, half3 exponent); एपीआई लेवल 24 में जोड़ा गया
half4 native_powr(half4 base, half4 exponent); एपीआई लेवल 24 में जोड़ा गया
पैरामीटर
निचला भागयह वैल्यू 0.f और 256.f के बीच होनी चाहिए. यह फ़ंक्शन, शून्य के बहुत करीब की वैल्यू के लिए सटीक नहीं है.
घातांकयह वैल्यू -15.f और 15.f के बीच होनी चाहिए.

तेज़ी से अनुमानित (base ^ exponent).

powr() फ़ंक्शन के बारे में भी जानें.

native_recip : अनुमानित रिसिप्रोकल

float native_recip(float v); एपीआई लेवल 21 में जोड़ा गया
float2 native_recip(float2 v); एपीआई लेवल 21 में जोड़ा गया
float3 native_recip(float3 v); एपीआई लेवल 21 में जोड़ा गया
float4 native_recip(float4 v); एपीआई लेवल 21 में जोड़ा गया
half native_recip(half v); एपीआई लेवल 24 में जोड़ा गया
half2 native_recip(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 native_recip(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 native_recip(half4 v); एपीआई लेवल 24 में जोड़ा गया

किसी वैल्यू का अनुमानित उलटा दिखाता है.

half_recip() फ़ंक्शन के बारे में भी जानें.

native_rootn : nवां रूट का अनुमान

float native_rootn(float v, int n); एपीआई लेवल 21 में जोड़ा गया
float2 native_rootn(float2 v, int2 n); एपीआई लेवल 21 में जोड़ा गया
float3 native_rootn(float3 v, int3 n); एपीआई लेवल 21 में जोड़ा गया
float4 native_rootn(float4 v, int4 n); एपीआई लेवल 21 में जोड़ा गया
half native_rootn(half v, int n); एपीआई लेवल 24 में जोड़ा गया
half2 native_rootn(half2 v, int2 n); एपीआई लेवल 24 में जोड़ा गया
half3 native_rootn(half3 v, int3 n); एपीआई लेवल 24 में जोड़ा गया
half4 native_rootn(half4 v, int4 n); एपीआई लेवल 24 में जोड़ा गया

किसी वैल्यू के एनवें रूट का अनुमानित हिसाब लगाता है.

rootn() फ़ंक्शन के बारे में भी जानें.

native_rsqrt : किसी संख्या के वर्गमूल का अनुमानित उलटा

float native_rsqrt(float v); एपीआई लेवल 21 में जोड़ा गया
float2 native_rsqrt(float2 v); एपीआई लेवल 21 में जोड़ा गया
float3 native_rsqrt(float3 v); एपीआई लेवल 21 में जोड़ा गया
float4 native_rsqrt(float4 v); एपीआई लेवल 21 में जोड़ा गया
half native_rsqrt(half v); एपीआई लेवल 24 में जोड़ा गया
half2 native_rsqrt(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 native_rsqrt(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 native_rsqrt(half4 v); एपीआई लेवल 24 में जोड़ा गया

यह फ़ंक्शन, (1 / sqrt(v)) की अनुमानित वैल्यू दिखाता है.

rsqrt(), half_rsqrt() भी देखें.

native_sin : साइन फ़ंक्शन का अनुमानित वैल्यू

float native_sin(float v); एपीआई लेवल 21 में जोड़ा गया
float2 native_sin(float2 v); एपीआई लेवल 21 में जोड़ा गया
float3 native_sin(float3 v); एपीआई लेवल 21 में जोड़ा गया
float4 native_sin(float4 v); एपीआई लेवल 21 में जोड़ा गया
half native_sin(half v); एपीआई लेवल 24 में जोड़ा गया
half2 native_sin(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 native_sin(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 native_sin(half4 v); एपीआई लेवल 24 में जोड़ा गया

रेडियन में मापे गए किसी कोण का अनुमानित साइन दिखाता है.

sin() फ़ंक्शन के बारे में भी जानें.

native_sincos : साइन और कोसाइन का अनुमानित मान

float native_sincos(float v, float* cos); एपीआई लेवल 21 में जोड़ा गया
float2 native_sincos(float2 v, float2* cos); एपीआई लेवल 21 में जोड़ा गया
float3 native_sincos(float3 v, float3* cos); एपीआई लेवल 21 में जोड़ा गया
float4 native_sincos(float4 v, float4* cos); एपीआई लेवल 21 में जोड़ा गया
half native_sincos(half v, half* cos); एपीआई लेवल 24 में जोड़ा गया
half2 native_sincos(half2 v, half2* cos); एपीआई लेवल 24 में जोड़ा गया
half3 native_sincos(half3 v, half3* cos); एपीआई लेवल 24 में जोड़ा गया
half4 native_sincos(half4 v, half4* cos); एपीआई लेवल 24 में जोड़ा गया
पैरामीटर
vरेडियन में इनकमिंग वैल्यू.
cos*cos को कोसाइन वैल्यू पर सेट किया जाएगा.
रिटर्न
साइन.

किसी वैल्यू का अनुमानित साइन और कोसाइन दिखाता है.

sincos() फ़ंक्शन के बारे में भी जानें.

native_sinh : हाइपरबोलिक साइन का अनुमान

float native_sinh(float v); एपीआई लेवल 21 में जोड़ा गया
float2 native_sinh(float2 v); एपीआई लेवल 21 में जोड़ा गया
float3 native_sinh(float3 v); एपीआई लेवल 21 में जोड़ा गया
float4 native_sinh(float4 v); एपीआई लेवल 21 में जोड़ा गया
half native_sinh(half v); एपीआई लेवल 24 में जोड़ा गया
half2 native_sinh(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 native_sinh(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 native_sinh(half4 v); एपीआई लेवल 24 में जोड़ा गया

रेडियन में दी गई वैल्यू की हाइपरबोलिक साइन का अनुमानित मान दिखाता है.

sinh() फ़ंक्शन के बारे में भी जानें.

native_sinpi : किसी संख्या को पाई से गुणा करने पर, उसके साइन का अनुमानित मान

float native_sinpi(float v); एपीआई लेवल 21 में जोड़ा गया
float2 native_sinpi(float2 v); एपीआई लेवल 21 में जोड़ा गया
float3 native_sinpi(float3 v); एपीआई लेवल 21 में जोड़ा गया
float4 native_sinpi(float4 v); एपीआई लेवल 21 में जोड़ा गया
half native_sinpi(half v); एपीआई लेवल 24 में जोड़ा गया
half2 native_sinpi(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 native_sinpi(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 native_sinpi(half4 v); एपीआई लेवल 24 में जोड़ा गया

(v * pi) का अनुमानित साइन दिखाता है. (v * pi) को रेडियन में मेज़र किया जाता है.

डिग्री में मेज़र की गई वैल्यू का साइन पाने के लिए, sinpi(v / 180.f) को कॉल करें.

sinpi() फ़ंक्शन के बारे में भी जानें.

native_sqrt : स्क्वेयर रूट का अनुमान

float native_sqrt(float v); एपीआई लेवल 21 में जोड़ा गया
float2 native_sqrt(float2 v); एपीआई लेवल 21 में जोड़ा गया
float3 native_sqrt(float3 v); एपीआई लेवल 21 में जोड़ा गया
float4 native_sqrt(float4 v); एपीआई लेवल 21 में जोड़ा गया
half native_sqrt(half v); एपीआई लेवल 24 में जोड़ा गया
half2 native_sqrt(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 native_sqrt(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 native_sqrt(half4 v); एपीआई लेवल 24 में जोड़ा गया

sqrt(v) का अनुमानित मान दिखाता है.

sqrt(), half_sqrt() फ़ंक्शन के बारे में भी जानें.

native_tan : टेंगेंट का अनुमान

float native_tan(float v); एपीआई लेवल 21 में जोड़ा गया
float2 native_tan(float2 v); एपीआई लेवल 21 में जोड़ा गया
float3 native_tan(float3 v); एपीआई लेवल 21 में जोड़ा गया
float4 native_tan(float4 v); एपीआई लेवल 21 में जोड़ा गया
half native_tan(half v); एपीआई लेवल 24 में जोड़ा गया
half2 native_tan(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 native_tan(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 native_tan(half4 v); एपीआई लेवल 24 में जोड़ा गया

रेडियन में मापे गए किसी कोण का अनुमानित टैंजेंट दिखाता है.

native_tanh : हाइपरबोलिक टेंजेंट का अनुमान

float native_tanh(float v); एपीआई लेवल 21 में जोड़ा गया
float2 native_tanh(float2 v); एपीआई लेवल 21 में जोड़ा गया
float3 native_tanh(float3 v); एपीआई लेवल 21 में जोड़ा गया
float4 native_tanh(float4 v); एपीआई लेवल 21 में जोड़ा गया
half native_tanh(half v); एपीआई लेवल 24 में जोड़ा गया
half2 native_tanh(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 native_tanh(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 native_tanh(half4 v); एपीआई लेवल 24 में जोड़ा गया

किसी वैल्यू का अनुमानित हाइपरबोलिक टैंजेंट दिखाता है.

tanh() फ़ंक्शन के बारे में भी जानें.

native_tanpi : किसी संख्या को पाई से गुणा करने पर, उसके टेंगेंट का अनुमानित मान

float native_tanpi(float v); एपीआई लेवल 21 में जोड़ा गया
float2 native_tanpi(float2 v); एपीआई लेवल 21 में जोड़ा गया
float3 native_tanpi(float3 v); एपीआई लेवल 21 में जोड़ा गया
float4 native_tanpi(float4 v); एपीआई लेवल 21 में जोड़ा गया
half native_tanpi(half v); एपीआई लेवल 24 में जोड़ा गया
half2 native_tanpi(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 native_tanpi(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 native_tanpi(half4 v); एपीआई लेवल 24 में जोड़ा गया

(v * pi) का अनुमानित टैंजेंट दिखाता है. (v * pi) को रेडियन में मेज़र किया जाता है.

डिग्री में मेज़र की गई वैल्यू का टेंगेंट पाने के लिए, tanpi(v / 180.f) को कॉल करें.

tanpi() फ़ंक्शन के बारे में भी जानें.

nextafter : फ़्लोटिंग पॉइंट वाली अगली संख्या

float nextafter(float v, float target);
float2 nextafter(float2 v, float2 target);
float3 nextafter(float3 v, float3 target);
float4 nextafter(float4 v, float4 target);
half nextafter(half v, half target); एपीआई लेवल 24 में जोड़ा गया
half2 nextafter(half2 v, half2 target); एपीआई लेवल 24 में जोड़ा गया
half3 nextafter(half3 v, half3 target); एपीआई लेवल 24 में जोड़ा गया
half4 nextafter(half4 v, half4 target); एपीआई लेवल 24 में जोड़ा गया

v से टारगेट की ओर, फ़्लोटिंग पॉइंट वाली अगली संख्या दिखाता है.

rs_fp_relaxed मोड में, हो सकता है कि नॉर्मलाइज़ की गई इनपुट वैल्यू से नॉर्मलाइज़ की गई अगली वैल्यू न मिले. इसकी वजह यह है कि नॉर्मलाइज़ की गई वैल्यू का इस्तेमाल करना, रिलैक्स मोड में ज़रूरी नहीं है.

pow : किसी संख्या को किसी घात में बढ़ाना

float pow(float base, float exponent);
float2 pow(float2 base, float2 exponent);
float3 pow(float3 base, float3 exponent);
float4 pow(float4 base, float4 exponent);
half pow(half base, half exponent); एपीआई लेवल 24 में जोड़ा गया
half2 pow(half2 base, half2 exponent); एपीआई लेवल 24 में जोड़ा गया
half3 pow(half3 base, half3 exponent); एपीआई लेवल 24 में जोड़ा गया
half4 pow(half4 base, half4 exponent); एपीआई लेवल 24 में जोड़ा गया

यह फ़ंक्शन, base को पावर एक्सपोनेंट तक बढ़ाकर दिखाता है. जैसे, base ^ exponent.

pown() और powr() एक जैसे हैं. pown() में पूर्णांक एक्सपोनेंट होता है. powr() में, आधार को नॉन-नेगेटिव माना जाता है.

pown : किसी संख्या को पूर्णांक घात में बढ़ाना

float pown(float base, int exponent);
float2 pown(float2 base, int2 exponent);
float3 pown(float3 base, int3 exponent);
float4 pown(float4 base, int4 exponent);
half pown(half base, int exponent); एपीआई लेवल 24 में जोड़ा गया
half2 pown(half2 base, int2 exponent); एपीआई लेवल 24 में जोड़ा गया
half3 pown(half3 base, int3 exponent); एपीआई लेवल 24 में जोड़ा गया
half4 pown(half4 base, int4 exponent); एपीआई लेवल 24 में जोड़ा गया

यह फ़ंक्शन, base को पावर एक्सपोनेंट तक बढ़ाकर दिखाता है. जैसे, base ^ exponent.

pow() और powr() फ़ंक्शन एक जैसे हैं. दोनों फ़ंक्शन में एक्सपोनेंट के तौर पर फ़्लोट वैल्यू का इस्तेमाल किया जाता है. साथ ही, powr() फ़ंक्शन में यह भी माना जाता है कि बेस की वैल्यू, शून्य से ज़्यादा हो.

powr : किसी संख्या को किसी घात में बढ़ाना

float powr(float base, float exponent);
float2 powr(float2 base, float2 exponent);
float3 powr(float3 base, float3 exponent);
float4 powr(float4 base, float4 exponent);
half powr(half base, half exponent); एपीआई लेवल 24 में जोड़ा गया
half2 powr(half2 base, half2 exponent); एपीआई लेवल 24 में जोड़ा गया
half3 powr(half3 base, half3 exponent); एपीआई लेवल 24 में जोड़ा गया
half4 powr(half4 base, half4 exponent); एपीआई लेवल 24 में जोड़ा गया

यह फ़ंक्शन, base को पावर एक्सपोनेंट तक बढ़ाकर दिखाता है. जैसे, base ^ exponent. base की वैल्यू 0 से ज़्यादा होनी चाहिए.

pow() और pown() फ़ंक्शन एक जैसे हैं. दोनों फ़ंक्शन, बेस के बारे में कोई अनुमान नहीं लगाते. pow() फ़ंक्शन, फ़्लोट एक्सपोनेंट लेता है, जबकि pown() फ़ंक्शन, पूर्णांक लेता है.

native_powr() भी देखें.

radians : डिग्री को रेडियन में बदलता है

float radians(float v);
float2 रेडियंस(float2 v);
float3 रेडियंस(float3 v);
float4 रेडियंस(float4 v);
half रेडियन(half v); एपीआई लेवल 24 में जोड़ा गया
half2 रेडियन(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 रेडियन(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 रेडियन(half4 v); एपीआई लेवल 24 में जोड़ा गया

डिग्री को रेडियन में बदलता है.

remainder : किसी संख्या को किसी दूसरी संख्या से भाग देने पर बचे हुए अंक

float remainder(float numerator, float denominator);
float2 remainder(float2 numerator, float2 denominator);
float3 remainder(float3 numerator, float3 denominator);
float4 remainder(float4 numerator, float4 denominator);
half remainder(half numerator, half denominator); एपीआई लेवल 24 में जोड़ा गया
half2 remainder(half2 numerator, half2 denominator); एपीआई लेवल 24 में जोड़ा गया
half3 remainder(half3 numerator, half3 denominator); एपीआई लेवल 24 में जोड़ा गया
half4 remainder(half4 numerator, half4 denominator); एपीआई लेवल 24 में जोड़ा गया

यह फ़ंक्शन, (नंबरेटर / डेनोमिनेटर) का शेष दिखाता है. इसमें भागफल को सबसे नज़दीकी पूर्णांक पर राउंड किया जाता है.

fmod() फ़ंक्शन भी इसी तरह का है, लेकिन यह सबसे नज़दीक पूर्णांक के हिसाब से राउंड करता है. उदाहरण के लिए, fmod(-3.8f, 2.f) से -1.8f (-3.8f - -1.f * 2.f) का नतीजा मिलता है, जबकि remainder(-3.8f, 2.f) से 0.2f (-3.8f - -2.f * 2.f) का नतीजा मिलता है.

remquo : भागफल और शेष

float remquo(float numerator, float denominator, int* quotient);
float2 remquo(float2 numerator, float2 denominator, int2* quotient);
float3 remquo(float3 numerator, float3 denominator, int3* quotient);
float4 remquo(float4 numerator, float4 denominator, int4* quotient);
half remquo(half numerator, half denominator, int* quotient); एपीआई लेवल 24 में जोड़ा गया
half2 remquo(half2 numerator, half2 denominator, int2* quotient); एपीआई लेवल 24 में जोड़ा गया
half3 remquo(half3 numerator, half3 denominator, int3* quotient); एपीआई लेवल 24 में जोड़ा गया
half4 remquo(half4 numerator, half4 denominator, int4* quotient); एपीआई लेवल 24 में जोड़ा गया
पैरामीटर
न्यूमरेटरअंश (न्यूमरेटर).
डिनोमिनेटरडिनोमिनेटर.
अनुपात निकालें*quotient को पूर्णांक भागफल पर सेट किया जाएगा.
रिटर्न
बाकी बचे अंक, जो सिर्फ़ सबसे छोटे तीन बिट के लिए सटीक होते हैं.

(नंबरेटर / डेनोमिनेटर) का भागफल और शेषफल दिखाता है.

क्वोटेंट के साइन और सबसे नीचे के तीन बिट ही सटीक होते हैं.

यह फ़ंक्शन, समय-समय पर होने वाले फ़ंक्शन लागू करने के लिए काम का है. भागफल के सबसे छोटे तीन बिट से क्वाड्रेंट का पता चलता है और शेष से क्वाड्रेंट में दूरी का पता चलता है. उदाहरण के लिए, sin(x) को लागू करने पर, x की बहुत बड़ी वैल्यू को सीमित रेंज में बदलने के लिए, remquo(x, PI / 2.f, &quadrant) को कॉल किया जा सकता है.

उदाहरण: remquo(-23.5f, 8.f, &quot), quot के सबसे निचले तीन बिट को 3 पर सेट करता है और साइन को नेगेटिव पर सेट करता है. यह 0.5f दिखाता है.

rint : सबसे छोटे पूर्णांक पर राउंड करें

float rint(float v);
float2 rint(float2 v);
float3 rint(float3 v);
float4 rint(float4 v);
half rint(half v); एपीआई लेवल 24 में जोड़ा गया
half2 rint(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 rint(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 rint(half4 v); एपीआई लेवल 24 में जोड़ा गया

सबसे करीब वाली पूरी संख्या में बदल देता है.

rint() फ़ंक्शन, आधी वैल्यू को सम में राउंड करता है. उदाहरण के लिए, rint(0.5f) से 0.f और rint(1.5f) से 2.f मिलता है. इसी तरह, rint(-0.5f) से -0.f और rint(-1.5f) से -2.f मिलता है.

round() फ़ंक्शन भी इसी तरह काम करता है, लेकिन यह शून्य से दूर की ओर पूर्णांक बनाता है. trunc() फ़ंक्शन, दशमलव वाली संख्या को छोटा कर देता है.

rootn : Nth root

float rootn(float v, int n);
float2 rootn(float2 v, int2 n);
float3 rootn(float3 v, int3 n);
float4 rootn(float4 v, int4 n);
half rootn(half v, int n); एपीआई लेवल 24 में जोड़ा गया
half2 rootn(half2 v, int2 n); एपीआई लेवल 24 में जोड़ा गया
half3 rootn(half3 v, int3 n); एपीआई लेवल 24 में जोड़ा गया
half4 rootn(half4 v, int4 n); एपीआई लेवल 24 में जोड़ा गया

किसी वैल्यू का एनवां रूट निकालता है.

native_rootn() भी देखें.

round : शून्य से दूर राउंड करें

float round(float v);
float2 round(float2 v);
float3 round(float3 v);
float4 round(float4 v);
half round(half v); एपीआई लेवल 24 में जोड़ा गया
half2 round(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 round(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 round(half4 v); एपीआई लेवल 24 में जोड़ा गया

सबसे करीबी पूर्णांक वैल्यू पर राउंड करें.

round() फ़ंक्शन, आधी वैल्यू को शून्य से दूर रखता है. उदाहरण के लिए, round(0.5f) से 1.f और round(1.5f) से 2.f मिलता है. इसी तरह, round(-0.5f) से -1.f और round(-1.5f) से -2.f मिलता है.

rint() फ़ंक्शन भी इसी तरह काम करता है. हालांकि, यह आधी वैल्यू को सम संख्या पर राउंड करता है. trunc() फ़ंक्शन, दशमलव वाली संख्या के दशमलव के बाद के अंकों को काट देता है.

rsClamp : किसी वैल्यू को रेंज में सीमित करना

char rsClamp(char amount, char low, char high);
int rsClamp(int amount, int low, int high);
short rsClamp(short amount, short low, short high);
uchar rsClamp(uchar amount, uchar low, uchar high);
uint rsClamp(uint amount, uint low, uint high);
ushort rsClamp(ushort amount, ushort low, ushort high);
पैरामीटर
रकमक्लैंप की जाने वाली वैल्यू.
कमनिचली सीमा.
तेज़ऊपरी सीमा.

अब काम नहीं करता. इसके बजाय, clamp() का इस्तेमाल करें.

वैल्यू को कम और ज़्यादा के बीच क्लैंप करें.

rsFrac : फ़्लोट वैल्यू के दशमलव वाले हिस्से को दिखाता है

float rsFrac(float v);

अब काम नहीं करता. इसके बजाय, fract() का इस्तेमाल करें.

फ़्लोट वैल्यू के दशमलव वाले हिस्से को दिखाता है

rsRand : स्यूडो-रैंडम नंबर

float rsRand(float max_value);
float rsRand(float min_value, float max_value);
int rsRand(int max_value);
int rsRand(int min_value, int max_value);

0 (या min_value) और max_malue के बीच कोई वैल्यू दिखाता है.

rsqrt : वर्गमूल का व्युत्क्रम

float rsqrt(float v);
float2 rsqrt(float2 v);
float3 rsqrt(float3 v);
float4 rsqrt(float4 v);
half rsqrt(half v); एपीआई लेवल 24 में जोड़ा गया
half2 rsqrt(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 rsqrt(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 rsqrt(half4 v); एपीआई लेवल 24 में जोड़ा गया

(1 / sqrt(v)) दिखाता है.

half_rsqrt(), native_rsqrt() भी देखें.

sign : वैल्यू का साइन

float sign(float v);
float2 sign(float2 v);
float3 sign(float3 v);
float4 sign(float4 v);
half sign(half v); एपीआई लेवल 24 में जोड़ा गया
half2 sign(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 sign(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 sign(half4 v); एपीआई लेवल 24 में जोड़ा गया

किसी वैल्यू का साइन दिखाता है.

if (v < 0) return -1.f; else if (v > 0) return 1.f; else return 0.f;

sin : साइन फ़ंक्शन

float sin(float v);
float2 sin(float2 v);
float3 sin(float3 v);
float4 sin(float4 v);
half sin(half v); एपीआई लेवल 24 में जोड़ा गया
half2 sin(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 sin(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 sin(half4 v); एपीआई लेवल 24 में जोड़ा गया

रेडियन में मापे गए कोण का साइन दिखाता है.

native_sin() भी देखें.

sincos : साइन और कोसाइन

float sincos(float v, float* cos);
float2 sincos(float2 v, float2* cos);
float3 sincos(float3 v, float3* cos);
float4 sincos(float4 v, float4* cos);
half sincos(half v, half* cos); एपीआई लेवल 24 में जोड़ा गया
half2 sincos(half2 v, half2* cos); एपीआई लेवल 24 में जोड़ा गया
half3 sincos(half3 v, half3* cos); एपीआई लेवल 24 में जोड़ा गया
half4 sincos(half4 v, half4* cos); एपीआई लेवल 24 में जोड़ा गया
पैरामीटर
vरेडियन में इनकमिंग वैल्यू.
cos*cos को कोसाइन वैल्यू पर सेट किया जाएगा.
रिटर्न
v का साइन.

किसी वैल्यू का साइन और कोसाइन दिखाता है.

native_sincos() भी देखें.

sinh : हाइपरबोलिक साइन

float sinh(float v);
float2 sinh(float2 v);
float3 sinh(float3 v);
float4 sinh(float4 v);
half sinh(half v); एपीआई लेवल 24 में जोड़ा गया
half2 sinh(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 sinh(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 sinh(half4 v); एपीआई लेवल 24 में जोड़ा गया

v का हाइपरबोलिक साइन दिखाता है. v को रेडियन में मेज़र किया जाता है.

native_sinh() भी देखें.

sinpi : पाई से गुणा की गई संख्या का साइन

float sinpi(float v);
float2 sinpi(float2 v);
float3 sinpi(float3 v);
float4 sinpi(float4 v);
half sinpi(half v); एपीआई लेवल 24 में जोड़ा गया
half2 sinpi(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 sinpi(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 sinpi(half4 v); एपीआई लेवल 24 में जोड़ा गया

(v * pi) की साइन दिखाता है. (v * pi) को रेडियन में मेज़र किया जाता है.

डिग्री में मेज़र की गई वैल्यू का साइन पाने के लिए, sinpi(v / 180.f) को कॉल करें.

native_sinpi() भी देखें.

sqrt : वर्गमूल

float sqrt(float v);
float2 sqrt(float2 v);
float3 sqrt(float3 v);
float4 sqrt(float4 v);
half sqrt(half v); एपीआई लेवल 24 में जोड़ा गया
half2 sqrt(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 sqrt(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 sqrt(half4 v); एपीआई लेवल 24 में जोड़ा गया

किसी वैल्यू का स्क्वेयर रूट दिखाता है.

half_sqrt(), native_sqrt() भी देखें.

step : किसी वैल्यू से कम होने पर 0, अन्यथा 1

float step(float edge, float v);
float2 step(float edge, float2 v); एपीआई लेवल 21 में जोड़ा गया
float2 step(float2 edge, float v);
float2 step(float2 edge, float2 v);
float3 step(float edge, float3 v); एपीआई लेवल 21 में जोड़ा गया
float3 step(float3 edge, float v);
float3 step(float3 edge, float3 v);
float4 step(float edge, float4 v); एपीआई लेवल 21 में जोड़ा गया
float4 step(float4 edge, float v);
float4 step(float4 edge, float4 v);
half step(half edge, half v); एपीआई लेवल 24 में जोड़ा गया
half2 step(half edge, half2 v); एपीआई लेवल 24 में जोड़ा गया
half2 step(half2 edge, half v); एपीआई लेवल 24 में जोड़ा गया
half2 step(half2 edge, half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 step(half edge, half3 v); एपीआई लेवल 24 में जोड़ा गया
half3 step(half3 edge, half v); एपीआई लेवल 24 में जोड़ा गया
half3 step(half3 edge, half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 step(half edge, half4 v); एपीआई लेवल 24 में जोड़ा गया
half4 step(half4 edge, half v); एपीआई लेवल 24 में जोड़ा गया
half4 step(half4 edge, half4 v); एपीआई लेवल 24 में जोड़ा गया

अगर v < edge है, तो 0.f दिखाता है. अगर ऐसा नहीं है, तो 1.f दिखाता है.

यह लूप और ब्रांचिंग निर्देशों का इस्तेमाल किए बिना, शर्त के हिसाब से कैलकुलेशन बनाने के लिए मददगार हो सकता है. उदाहरण के लिए, किसी वेक्टर के एलिमेंट के लिए (a[i] < b[i]) ? 0.f : atan2(a[i], b[i]) का हिसाब लगाने के बजाय, step(a, b) * atan2(a, b) का इस्तेमाल किया जा सकता है.

tan : टेंगेंट

float tan(float v);
float2 tan(float2 v);
float3 tan(float3 v);
float4 tan(float4 v);
half tan(half v); एपीआई लेवल 24 में जोड़ा गया
half2 tan(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 tan(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 tan(half4 v); एपीआई लेवल 24 में जोड़ा गया

रेडियन में मापे गए कोण का टैंजेंट दिखाता है.

native_tan() भी देखें.

tanh : हाइपरबोलिक टेंगेंट

float tanh(float v);
float2 tanh(float2 v);
float3 tanh(float3 v);
float4 tanh(float4 v);
half tanh(half v); एपीआई लेवल 24 में जोड़ा गया
half2 tanh(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 tanh(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 tanh(half4 v); एपीआई लेवल 24 में जोड़ा गया

किसी वैल्यू का हाइपरबोलिक टैंजेंट दिखाता है.

native_tanh() भी देखें.

tanpi : किसी संख्या को पाई से गुणा करने पर, उसका टेंगेंट

float tanpi(float v);
float2 tanpi(float2 v);
float3 tanpi(float3 v);
float4 tanpi(float4 v);
half tanpi(half v); एपीआई लेवल 24 में जोड़ा गया
half2 tanpi(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 tanpi(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 tanpi(half4 v); एपीआई लेवल 24 में जोड़ा गया

(v * pi) का टैंजेंट दिखाता है. (v * pi) को रेडियन में मेज़र किया जाता है.

डिग्री में मेज़र की गई वैल्यू का टेंगेंट पाने के लिए, tanpi(v / 180.f) को कॉल करें.

native_tanpi() भी देखें.

tgamma : गामा फ़ंक्शन

float tgamma(float v);
float2 tgamma(float2 v);
float3 tgamma(float3 v);
float4 tgamma(float4 v);
half tgamma(half v); एपीआई लेवल 24 में जोड़ा गया
half2 tgamma(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 tgamma(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 tgamma(half4 v); एपीआई लेवल 24 में जोड़ा गया

किसी वैल्यू का गामा फ़ंक्शन दिखाता है.

lgamma() फ़ंक्शन के बारे में भी जानें.

trunc : फ़्लोटिंग पॉइंट को छोटा करता है

float trunc(float v);
float2 trunc(float2 v);
float3 trunc(float3 v);
float4 trunc(float4 v);
half trunc(half v); एपीआई लेवल 24 में जोड़ा गया
half2 trunc(half2 v); एपीआई लेवल 24 में जोड़ा गया
half3 trunc(half3 v); एपीआई लेवल 24 में जोड़ा गया
half4 trunc(half4 v); एपीआई लेवल 24 में जोड़ा गया

काट-छांट करके, इंटिग्रल के तौर पर राउंड करता है.

उदाहरण के लिए, trunc(1.7f) से 1.f और trunc(-1.7f) से -1.f मिलता है.

संख्या को दशमलव के बाद के अंकों की संख्या कम करने के अन्य विकल्पों के लिए, rint() और round() देखें.