หน้านี้ได้รับการแปลโดย Cloud Translation API

ค่าคงที่และฟังก์ชันทางคณิตศาสตร์ของ 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 บิตจะได้รับผลกระทบจากพรอมต์ rs_fp_relaxed และ rs_fp_full ใน rs_fp_relaxed ระบบอาจปัดค่าที่ต่ำกว่าปกติเป็น 0 และปัดเศษเป็น 0 ในทางกลับกัน rs_fp_full ต้องใช้การจัดการค่าที่ต่ำกว่าปกติอย่างถูกต้อง เช่น ค่าที่น้อยกว่า 1.17549435e-38f นอกจากนี้ rs_fp_rull ยังกำหนดให้ปัดเศษเป็นค่าใกล้ที่สุดโดยปัดเศษทศนิยมให้ลงท้ายด้วยเลขคู่

คุณสามารถปรับสมดุลความแม่นยำ/ความเร็วได้โดยใช้ตัวแปรของฟังก์ชันคณิตศาสตร์ทั่วไป ฟังก์ชันที่มีชื่อขึ้นต้นด้วย

native_: อาจมีการนําฮาร์ดแวร์ที่กำหนดเองมาใช้ซึ่งมีความแม่นยำน้อยกว่า นอกจากนี้ ระบบอาจปัดค่าที่ต่ำกว่าปกติเป็น 0, ใช้การปัดทศนิยมลง และอาจจัดการอินพุต NaN และอินพุต Infinity อย่างไม่ถูกต้อง
half_: อาจทําการคํานวณภายในโดยใช้ตัวเลขทศนิยม 16 บิต นอกจากนี้ ระบบอาจปัดค่าที่ต่ำกว่าปกติเป็น 0 และอาจปัดเศษให้ใกล้กับ 0

สรุป

ค่าคงที่
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	รากที่ 3
ceil	จํานวนเต็มที่น้อยที่สุดซึ่งไม่ต่ำกว่าค่า
clamp	จำกัดค่าให้อยู่ในช่วง
clz	จำนวนบิต 0 นําหน้า
copysign	คัดลอกเครื่องหมายของตัวเลขไปยังอีกตัวเลขหนึ่ง
cos	โคไซน์
cosh	โคไซน์ไฮเปอร์โบลิก
cospi	โคไซน์ของจำนวนที่คูณด้วย pi
องศา	แปลงเรเดียนเป็นองศา
erf	ฟังก์ชันข้อผิดพลาดทางคณิตศาสตร์
erfc	ฟังก์ชันข้อผิดพลาดเสริมทางคณิตศาสตร์
exp	e ยกกำลังตัวเลข
exp10	10 ยกกำลังตัวเลข
exp2	2 ยกกำลังตัวเลข
expm1	e ยกกำลังจำนวนลบ 1
fabs	ค่าสัมบูรณ์ของตัวเลขทศนิยม
fdim	ผลต่างระหว่าง 2 ค่าที่เป็นบวก
floor	จำนวนเต็มที่น้อยที่สุดซึ่งไม่มากกว่าค่า
fma	คูณและเพิ่ม
fmax	ไม่เกิน 2 รายการ
fmin	อย่างน้อย 2 รายการ
fmod	มอดูโล
fract	ส่วนที่เป็นเศษทศนิยมบวก
frexp	เศษทศนิยมและเลขชี้กำลังของเลขฐาน 2
half_recip	ผลหารที่คำนวณด้วยความแม่นยำ 16 บิต
half_rsqrt	ผลหารของรากที่สองที่คำนวณด้วยความแม่นยำ 16 บิต
half_sqrt	รากที่สองที่คำนวณด้วยความแม่นยำ 16 บิต
hypot	เส้นทแยงมุม
ilogb	เลขยกกำลังฐาน 2
ldexp	สร้างทศนิยมจากเศษทศนิยมและตัวคูณ
lgamma	ลอการิทึมธรรมชาติของฟังก์ชันแกมมา
log	ลอการิทึมธรรมชาติ
log10	ลอการิทึมฐาน 10
log1p	ลอการิทึมธรรมชาติของค่าบวก 1
log2	ลอการิทึมฐาน 2
logb	เลขยกกำลังฐาน 2
mad	คูณและเพิ่ม
max	สูงสุด
นาที	ต่ำสุด
mix	ผสมค่า 2 ค่าเข้าด้วยกัน
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	ค่าโคไซน์โดยประมาณของจำนวนที่คูณด้วย pi
native_divide	การหารแบบใกล้เคียง
native_exp	ค่าประมาณของ e ยกกำลังจำนวน
native_exp10	ประมาณ 10 ยกกำลังจำนวน
native_exp2	2 ยกกำลังจำนวนหนึ่งโดยประมาณ
native_expm1	ค่าประมาณของ e ยกกำลังจำนวนลบ 1
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	ค่าไซน์โดยประมาณของจำนวนที่คูณด้วย pi
native_sqrt	รากที่สองโดยประมาณ
native_tan	แทนเจนต์โดยประมาณ
native_tanh	ไฮเปอร์โบลิกแทนเจนต์โดยประมาณ
native_tanpi	ค่าแทนเจนต์โดยประมาณของจำนวนที่คูณด้วย pi
nextafter	ตัวเลขทศนิยมถัดไป
pow	ฐานที่ยกกำลัง
pown	ฐานที่ยกกำลังเป็นจำนวนเต็ม
powr	ฐานบวกที่ยกกำลัง
radians	แปลงองศาเป็นเรเดียน
remainder	เศษทศนิยมของการหาร
remquo	เศษและผลหารของการหาร
rint	ปัดเศษให้ลงตัว
rootn	รากที่ n
round	ปัดเศษออกจาก 0
rsRand	ตัวเลขสุ่มเทียม
rsqrt	ตัวผกผันของรากที่สอง
sign	เครื่องหมายของค่า
sin	ไซน์
sincos	ไซน์และโคไซน์
sinh	ไซน์ไฮเปอร์โบลิก
sinpi	ไซน์ของจำนวนที่คูณด้วย pi
sqrt	รากที่สอง
step	0 หากน้อยกว่าค่าหนึ่งๆ หรือ 1 หากมากกว่า
tan	แทนเจนต์
tanh	แทนเจนต์ไฮเพอร์โบลิก
tanpi	แทนเจนต์ของจำนวนที่คูณด้วย pi
tgamma	ฟังก์ชันแกมมา
trunc	ตัดจุดลอยตัว

ฟังก์ชันที่เลิกใช้งาน
rsClamp	เลิกใช้งาน จำกัดค่าให้อยู่ในช่วง
rsFrac	เลิกใช้งาน แสดงผลส่วนที่เป็นเศษทศนิยมของตัวเลขทศนิยม

ค่าคงที่

M_1_PI : 1 / pi เป็นเลขทศนิยม 32 บิต

ค่า: 0.318309886183790671537767526745028724f

ค่าผกผันของ pi เป็นจำนวนลอยตัว 32 บิต

M_2_PI : 2 / pi เป็นเลขทศนิยม 32 บิต

ค่า: 0.636619772367581343075535053490057448f

2 หารด้วย pi เป็นจำนวนลอยตัว 32 บิต

M_2_SQRTPI : 2 / sqrt(pi) เป็นเลขทศนิยม 32 บิต

ค่า: 1.128379167095512573896158903121545172f

2 หารด้วยรากที่ 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

ลอการิทึมธรรมชาติของ 2 ในรูปแบบเลขทศนิยม 32 บิต

M_LOG10E : log_10(e) เป็นเลขทศนิยม 32 บิต

ค่า: 0.434294481903251827651128918916605082f

ลอการิทึมฐาน 10 ของ e ในรูปแบบเลขทศนิยม 32 บิต

M_LOG2E : log_2(e) เป็นเลขทศนิยม 32 บิต

ค่า: 1.442695040888963407359924681001892137f

ลอการิทึมฐาน 2 ของ e เป็นเลขทศนิยม 32 บิต

M_PI : pi เป็นเลขทศนิยม 32 บิต

ค่า: 3.141592653589793238462643383279502884f

ค่าคงที่ pi เป็นจำนวนลอยตัว 32 บิต

M_PI_2 : pi / 2 เป็นเลขทศนิยม 32 บิต

ค่า: 1.570796326794896619231321691639751442f

Pi หารด้วย 2 ในรูปแบบจำนวนลอยตัว 32 บิต

M_PI_4 : pi / 4 เป็นเลขทศนิยม 32 บิต

ค่า: 0.785398163397448309615660845819875721f

Pi หารด้วย 4 ในรูปแบบจำนวนลอยตัว 32 บิต

M_SQRT1_2 : 1 / sqrt(2) เป็นทศนิยม 32 บิต

ค่า: 0.707106781186547524400844362104849039f

ตัวผกผันของรากที่ 2 ของ 2 ในรูปแบบเลขทศนิยม 32 บิต

M_SQRT2 : sqrt(2) เป็นเลขทศนิยม 32 บิต

ค่า: 1.414213562373095048801688724209698079f

รากที่สองของ 2 ในรูปแบบจำนวนลอยตัว 32 บิต

ฟังก์ชัน

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);	เพิ่มใน API ระดับ 24
half2 acos(half2 v);	เพิ่มใน API ระดับ 24
half3 acos(half3 v);	เพิ่มใน API ระดับ 24
half4 acos(half4 v);	เพิ่มใน API ระดับ 24

จะแสดงผลโคไซน์ผกผันเป็นเรเดียน

โปรดดูnative_acos() ด้วย

acosh : โคไซน์ไฮเปอร์โบลิกผกผัน

float acosh(float v);
float2 acosh(float2 v);
float3 acosh(float3 v);
float4 acosh(float4 v);
half acosh(half v);	เพิ่มใน API ระดับ 24
half2 acosh(half2 v);	เพิ่มใน API ระดับ 24
half3 acosh(half3 v);	เพิ่มใน API ระดับ 24
half4 acosh(half4 v);	เพิ่มใน API ระดับ 24

จะแสดงผลโคไซน์ไฮเปอร์โบลิกผกผันเป็นเรเดียน

โปรดดูnative_acosh() ด้วย

acospi : โคไซน์ผกผันหารด้วย pi

float acospi(float v);
float2 acospi(float2 v);
float3 acospi(float3 v);
float4 acospi(float4 v);
half acospi(half v);	เพิ่มใน API ระดับ 24
half2 acospi(half2 v);	เพิ่มใน API ระดับ 24
half3 acospi(half3 v);	เพิ่มใน API ระดับ 24
half4 acospi(half4 v);	เพิ่มใน API ระดับ 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);	เพิ่มใน API ระดับ 24
half2 asin(half2 v);	เพิ่มใน API ระดับ 24
half3 asin(half3 v);	เพิ่มใน API ระดับ 24
half4 asin(half4 v);	เพิ่มใน API ระดับ 24

จะแสดงผลไซน์ผกผันเป็นเรเดียน

โปรดดูnative_asin() ด้วย

asinh : ไซน์ไฮเปอร์โบลิกผกผัน

float asinh(float v);
float2 asinh(float2 v);
float3 asinh(float3 v);
float4 asinh(float4 v);
half asinh(half v);	เพิ่มใน API ระดับ 24
half2 asinh(half2 v);	เพิ่มใน API ระดับ 24
half3 asinh(half3 v);	เพิ่มใน API ระดับ 24
half4 asinh(half4 v);	เพิ่มใน API ระดับ 24

จะแสดงผลไซน์ไฮเปอร์โบลิกผกผันเป็นเรเดียน

ดูข้อมูลเพิ่มเติมได้ที่ native_asinh()

asinpi : ไซน์ผกผันหารด้วย pi

float asinpi(float v);
float2 asinpi(float2 v);
float3 asinpi(float3 v);
float4 asinpi(float4 v);
half asinpi(half v);	เพิ่มใน API ระดับ 24
half2 asinpi(half2 v);	เพิ่มใน API ระดับ 24
half3 asinpi(half3 v);	เพิ่มใน API ระดับ 24
half4 asinpi(half4 v);	เพิ่มใน API ระดับ 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);	เพิ่มใน API ระดับ 24
half2 atan(half2 v);	เพิ่มใน API ระดับ 24
half3 atan(half3 v);	เพิ่มใน API ระดับ 24
half4 atan(half4 v);	เพิ่มใน API ระดับ 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);	เพิ่มใน API ระดับ 24
half2 atan2(half2 numerator, half2 denominator);	เพิ่มใน API ระดับ 24
half3 atan2(half3 numerator, half3 denominator);	เพิ่มใน API ระดับ 24
half4 atan2(half4 numerator, half4 denominator);	เพิ่มใน API ระดับ 24

พารามิเตอร์

ตัวเศษ	ตัวเศษ
ตัวส่วน	ตัวส่วน อาจเป็น 0

แสดงผลแทนเจนต์ผกผันของ (numerator / denominator) เป็นเรเดียน

ดู native_atan2() เพิ่มเติม

atan2pi : ฟังก์ชันตรีโกณผั่วผันกลับของอัตราส่วนหารด้วย pi

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);	เพิ่มใน API ระดับ 24
half2 atan2pi(half2 numerator, half2 denominator);	เพิ่มใน API ระดับ 24
half3 atan2pi(half3 numerator, half3 denominator);	เพิ่มใน API ระดับ 24
half4 atan2pi(half4 numerator, half4 denominator);	เพิ่มใน API ระดับ 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);	เพิ่มใน API ระดับ 24
half2 atanh(half2 v);	เพิ่มใน API ระดับ 24
half3 atanh(half3 v);	เพิ่มใน API ระดับ 24
half4 atanh(half4 v);	เพิ่มใน API ระดับ 24

จะแสดงผลแทนเจนต์ไฮเปอร์โบลิกผกผันเป็นเรเดียน

โปรดดูnative_atanh() ด้วย

atanpi : ฟังก์ชันตรีโกณผั่วผันหารด้วย pi

float atanpi(float v);
float2 atanpi(float2 v);
float3 atanpi(float3 v);
float4 atanpi(float4 v);
half atanpi(half v);	เพิ่มใน API ระดับ 24
half2 atanpi(half2 v);	เพิ่มใน API ระดับ 24
half3 atanpi(half3 v);	เพิ่มใน API ระดับ 24
half4 atanpi(half4 v);	เพิ่มใน API ระดับ 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);	เพิ่มใน API ระดับ 24
half2 cbrt(half2 v);	เพิ่มใน API ระดับ 24
half3 cbrt(half3 v);	เพิ่มใน API ระดับ 24
half4 cbrt(half4 v);	เพิ่มใน API ระดับ 24

แสดงผลรากที่ 3

โปรดดูnative_cbrt() ด้วย

ceil : จำนวนเต็มขนาดเล็กที่สุดที่มากกว่าหรือเท่ากับค่า

float ceil(float v);
float2 ceil(float2 v);
float3 ceil(float3 v);
float4 ceil(float4 v);
half ceil(half v);	เพิ่มใน API ระดับ 24
half2 ceil(half2 v);	เพิ่มใน API ระดับ 24
half3 ceil(half3 v);	เพิ่มใน API ระดับ 24
half4 ceil(half4 v);	เพิ่มใน API ระดับ 24

แสดงผลจำนวนเต็มที่น้อยที่สุดซึ่งไม่ต่ำกว่าค่า

เช่น ceil(1.2f) จะแสดงผลเป็น 2.f และ ceil(-1.2f) จะแสดงผลเป็น -1.f

ดูข้อมูลเพิ่มเติมได้ที่ floor()

clamp : จำกัดค่าให้อยู่ในช่วง

char clamp(char value, char min_value, char max_value);	เพิ่มใน API ระดับ 19
char2 clamp(char2 value, char min_value, char max_value);	เพิ่มใน API ระดับ 19
char2 clamp(char2 value, char2 min_value, char2 max_value);	เพิ่มใน API ระดับ 19
char3 clamp(char3 value, char min_value, char max_value);	เพิ่มใน API ระดับ 19
char3 clamp(char3 value, char3 min_value, char3 max_value);	เพิ่มใน API ระดับ 19
char4 clamp(char4 value, char min_value, char max_value);	เพิ่มใน API ระดับ 19
char4 clamp(char4 value, char4 min_value, char4 max_value);	เพิ่มใน API ระดับ 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);	เพิ่มใน API ระดับ 24
half2 clamp(half2 value, half min_value, half max_value);	เพิ่มใน API ระดับ 24
half2 clamp(half2 value, half2 min_value, half2 max_value);	เพิ่มใน API ระดับ 24
half3 clamp(half3 value, half min_value, half max_value);	เพิ่มใน API ระดับ 24
half3 clamp(half3 value, half3 min_value, half3 max_value);	เพิ่มใน API ระดับ 24
half4 clamp(half4 value, half min_value, half max_value);	เพิ่มใน API ระดับ 24
half4 clamp(half4 value, half4 min_value, half4 max_value);	เพิ่มใน API ระดับ 24
int clamp(int value, int min_value, int max_value);	เพิ่มใน API ระดับ 19
int2 clamp(int2 value, int min_value, int max_value);	เพิ่มใน API ระดับ 19
int2 clamp(int2 value, int2 min_value, int2 max_value);	เพิ่มใน API ระดับ 19
int3 clamp(int3 value, int min_value, int max_value);	เพิ่มใน API ระดับ 19
int3 clamp(int3 value, int3 min_value, int3 max_value);	เพิ่มใน API ระดับ 19
int4 clamp(int4 value, int min_value, int max_value);	เพิ่มใน API ระดับ 19
int4 clamp(int4 value, int4 min_value, int4 max_value);	เพิ่มใน API ระดับ 19
long clamp(long value, long min_value, long max_value);	เพิ่มใน API ระดับ 19
long2 clamp(long2 value, long min_value, long max_value);	เพิ่มใน API ระดับ 19
long2 clamp(long2 value, long2 min_value, long2 max_value);	เพิ่มใน API ระดับ 19
long3 clamp(long3 value, long min_value, long max_value);	เพิ่มใน API ระดับ 19
long3 clamp(long3 value, long3 min_value, long3 max_value);	เพิ่มใน API ระดับ 19
long4 clamp(long4 value, long min_value, long max_value);	เพิ่มใน API ระดับ 19
long4 clamp(long4 value, long4 min_value, long4 max_value);	เพิ่มใน API ระดับ 19
short clamp(short value, short min_value, short max_value);	เพิ่มใน API ระดับ 19
short2 clamp(short2 value, short min_value, short max_value);	เพิ่มใน API ระดับ 19
short2 clamp(short2 value, short2 min_value, short2 max_value);	เพิ่มใน API ระดับ 19
short3 clamp(short3 value, short min_value, short max_value);	เพิ่มใน API ระดับ 19
short3 clamp(short3 value, short3 min_value, short3 max_value);	เพิ่มใน API ระดับ 19
short4 clamp(short4 value, short min_value, short max_value);	เพิ่มใน API ระดับ 19
short4 clamp(short4 value, short4 min_value, short4 max_value);	เพิ่มใน API ระดับ 19
uchar clamp(uchar value, uchar min_value, uchar max_value);	เพิ่มใน API ระดับ 19
uchar2 clamp(uchar2 value, uchar min_value, uchar max_value);	เพิ่มใน API ระดับ 19
uchar2 clamp(uchar2 value, uchar2 min_value, uchar2 max_value);	เพิ่มใน API ระดับ 19
uchar3 clamp(uchar3 value, uchar min_value, uchar max_value);	เพิ่มใน API ระดับ 19
uchar3 clamp(uchar3 value, uchar3 min_value, uchar3 max_value);	เพิ่มใน API ระดับ 19
uchar4 clamp(uchar4 value, uchar min_value, uchar max_value);	เพิ่มใน API ระดับ 19
uchar4 clamp(uchar4 value, uchar4 min_value, uchar4 max_value);	เพิ่มใน API ระดับ 19
uint clamp(uint value, uint min_value, uint max_value);	เพิ่มใน API ระดับ 19
uint2 clamp(uint2 value, uint min_value, uint max_value);	เพิ่มใน API ระดับ 19
uint2 clamp(uint2 value, uint2 min_value, uint2 max_value);	เพิ่มใน API ระดับ 19
uint3 clamp(uint3 value, uint min_value, uint max_value);	เพิ่มใน API ระดับ 19
uint3 clamp(uint3 value, uint3 min_value, uint3 max_value);	เพิ่มใน API ระดับ 19
uint4 clamp(uint4 value, uint min_value, uint max_value);	เพิ่มใน API ระดับ 19
uint4 clamp(uint4 value, uint4 min_value, uint4 max_value);	เพิ่มใน API ระดับ 19
ulong clamp(ulong value, ulong min_value, ulong max_value);	เพิ่มใน API ระดับ 19
ulong2 clamp(ulong2 value, ulong min_value, ulong max_value);	เพิ่มใน API ระดับ 19
ulong2 clamp(ulong2 value, ulong2 min_value, ulong2 max_value);	เพิ่มใน API ระดับ 19
ulong3 clamp(ulong3 value, ulong min_value, ulong max_value);	เพิ่มใน API ระดับ 19
ulong3 clamp(ulong3 value, ulong3 min_value, ulong3 max_value);	เพิ่มใน API ระดับ 19
ulong4 clamp(ulong4 value, ulong min_value, ulong max_value);	เพิ่มใน API ระดับ 19
ulong4 clamp(ulong4 value, ulong4 min_value, ulong4 max_value);	เพิ่มใน API ระดับ 19
ushort clamp(ushort value, ushort min_value, ushort max_value);	เพิ่มใน API ระดับ 19
ushort2 clamp(ushort2 value, ushort min_value, ushort max_value);	เพิ่มใน API ระดับ 19
ushort2 clamp(ushort2 value, ushort2 min_value, ushort2 max_value);	เพิ่มใน API ระดับ 19
ushort3 clamp(ushort3 value, ushort min_value, ushort max_value);	เพิ่มใน API ระดับ 19
ushort3 clamp(ushort3 value, ushort3 min_value, ushort3 max_value);	เพิ่มใน API ระดับ 19
ushort4 clamp(ushort4 value, ushort min_value, ushort max_value);	เพิ่มใน API ระดับ 19
ushort4 clamp(ushort4 value, ushort4 min_value, ushort4 max_value);	เพิ่มใน API ระดับ 19

พารามิเตอร์

ค่า	ค่าที่จะบีบอัด
min_value	ขอบเขตล่าง สเกลาร์ หรือเวกเตอร์ที่ตรงกัน
max_value	ขอบเขตบนต้องตรงกับประเภทของขอบเขตล่าง

จำกัดค่าให้อยู่ในช่วงต่ำสุดและสูงสุดที่ระบุ clamp() จะแสดงผล min_value หาก value < min_value, max_value หาก value > max_value ไม่เช่นนั้นแสดงผล value

การจำกัดมี 2 รูปแบบ ได้แก่ รูปแบบที่ค่าต่ำสุดและสูงสุดเป็นสกัลาร์ที่ใช้กับรายการทั้งหมดของค่า และอีกรูปแบบที่ค่าต่ำสุดและสูงสุดเป็นเวกเตอร์ด้วย

หาก 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);	เพิ่มใน API ระดับ 24
half2 copysign(half2 magnitude_value, half2 sign_value);	เพิ่มใน API ระดับ 24
half3 copysign(half3 magnitude_value, half3 sign_value);	เพิ่มใน API ระดับ 24
half4 copysign(half4 magnitude_value, half4 sign_value);	เพิ่มใน API ระดับ 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);	เพิ่มใน API ระดับ 24
half2 cos(half2 v);	เพิ่มใน API ระดับ 24
half3 cos(half3 v);	เพิ่มใน API ระดับ 24
half4 cos(half4 v);	เพิ่มใน API ระดับ 24

ส่งคืนค่าโคไซน์ของมุมที่วัดเป็นเรเดียน

ดูข้อมูลเพิ่มเติมได้ที่ native_cos()

cosh : โคไซน์ไฮเพอร์โบลิก

float cosh(float v);
float2 cosh(float2 v);
float3 cosh(float3 v);
float4 cosh(float4 v);
half cosh(half v);	เพิ่มใน API ระดับ 24
half2 cosh(half2 v);	เพิ่มใน API ระดับ 24
half3 cosh(half3 v);	เพิ่มใน API ระดับ 24
half4 cosh(half4 v);	เพิ่มใน API ระดับ 24

แสดงผลค่าไฮเปอร์โบลิกโคไซน์ของ v โดยที่ v จะวัดเป็นเรเดียน

ดูข้อมูลเพิ่มเติมได้ที่ native_cosh()

cospi : โคไซน์ของจำนวนที่คูณด้วย pi

float cospi(float v);
float2 cospi(float2 v);
float3 cospi(float3 v);
float4 cospi(float4 v);
half cospi(half v);	เพิ่มใน API ระดับ 24
half2 cospi(half2 v);	เพิ่มใน API ระดับ 24
half3 cospi(half3 v);	เพิ่มใน API ระดับ 24
half4 cospi(half4 v);	เพิ่มใน API ระดับ 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);	เพิ่มใน API ระดับ 24
half2 degrees(half2 v);	เพิ่มใน API ระดับ 24
half3 degrees(half3 v);	เพิ่มใน API ระดับ 24
half4 degrees(half4 v);	เพิ่มใน API ระดับ 24

แปลงจากเรเดียนเป็นองศา

erf : ฟังก์ชันข้อผิดพลาดทางคณิตศาสตร์

float erf(float v);
float2 erf(float2 v);
float3 erf(float3 v);
float4 erf(float4 v);
half erf(half v);	เพิ่มใน API ระดับ 24
half2 erf(half2 v);	เพิ่มใน API ระดับ 24
half3 erf(half3 v);	เพิ่มใน API ระดับ 24
half4 erf(half4 v);	เพิ่มใน API ระดับ 24

แสดงผลฟังก์ชันข้อผิดพลาด

erfc : ฟังก์ชันข้อผิดพลาดเสริมทางคณิตศาสตร์

float erfc(float v);
float2 erfc(float2 v);
float3 erfc(float3 v);
float4 erfc(float4 v);
half erfc(half v);	เพิ่มใน API ระดับ 24
half2 erfc(half2 v);	เพิ่มใน API ระดับ 24
half3 erfc(half3 v);	เพิ่มใน API ระดับ 24
half4 erfc(half4 v);	เพิ่มใน API ระดับ 24

แสดงผลฟังก์ชันข้อผิดพลาดเสริม

exp : e ยกกำลังตามจำนวน

float exp(float v);
float2 exp(float2 v);
float3 exp(float3 v);
float4 exp(float4 v);
half exp(half v);	เพิ่มใน API ระดับ 24
half2 exp(half2 v);	เพิ่มใน API ระดับ 24
half3 exp(half3 v);	เพิ่มใน API ระดับ 24
half4 exp(half4 v);	เพิ่มใน API ระดับ 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);	เพิ่มใน API ระดับ 24
half2 exp10(half2 v);	เพิ่มใน API ระดับ 24
half3 exp10(half3 v);	เพิ่มใน API ระดับ 24
half4 exp10(half4 v);	เพิ่มใน API ระดับ 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);	เพิ่มใน API ระดับ 24
half2 exp2(half2 v);	เพิ่มใน API ระดับ 24
half3 exp2(half3 v);	เพิ่มใน API ระดับ 24
half4 exp2(half4 v);	เพิ่มใน API ระดับ 24

แสดงผล 2 ยกกำลัง v เช่น 2.f ^ v

ดู native_exp2() เพิ่มเติม

expm1 : e ยกกำลังด้วยจำนวนลบ 1

float expm1(float v);
float2 expm1(float2 v);
float3 expm1(float3 v);
float4 expm1(float4 v);
half expm1(half v);	เพิ่มใน API ระดับ 24
half2 expm1(half2 v);	เพิ่มใน API ระดับ 24
half3 expm1(half3 v);	เพิ่มใน API ระดับ 24
half4 expm1(half4 v);	เพิ่มใน API ระดับ 24

แสดงผล e ยกกำลัง v ลบ 1 เช่น (e ^ v) - 1

ดู native_expm1() เพิ่มเติม

fabs : ค่าสัมบูรณ์ของประเภท float

float fabs(float v);
float2 fabs(float2 v);
float3 fabs(float3 v);
float4 fabs(float4 v);
half fabs(half v);	เพิ่มใน API ระดับ 24
half2 fabs(half2 v);	เพิ่มใน API ระดับ 24
half3 fabs(half3 v);	เพิ่มใน API ระดับ 24
half4 fabs(half4 v);	เพิ่มใน API ระดับ 24

แสดงผลค่าสัมบูรณ์ของ v ที่เป็นทศนิยม

สําหรับจำนวนเต็ม ให้ใช้ abs()

fdim : ผลต่างบวกระหว่าง 2 ค่า

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);	เพิ่มใน API ระดับ 24
half2 fdim(half2 a, half2 b);	เพิ่มใน API ระดับ 24
half3 fdim(half3 a, half3 b);	เพิ่มใน API ระดับ 24
half4 fdim(half4 a, half4 b);	เพิ่มใน API ระดับ 24

แสดงผลต่างที่เป็นบวกระหว่าง 2 ค่า

หาก 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);	เพิ่มใน API ระดับ 24
half2 floor(half2 v);	เพิ่มใน API ระดับ 24
half3 floor(half3 v);	เพิ่มใน API ระดับ 24
half4 floor(half4 v);	เพิ่มใน API ระดับ 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);	เพิ่มใน API ระดับ 24
half2 fma(half2 multiplicand1, half2 multiplicand2, half2 offset);	เพิ่มใน API ระดับ 24
half3 fma(half3 multiplicand1, half3 multiplicand2, half3 offset);	เพิ่มใน API ระดับ 24
half4 fma(half4 multiplicand1, half4 multiplicand2, half4 offset);	เพิ่มใน API ระดับ 24

คูณและบวก คืนสินค้า (multiplicand1 * multiplicand2) + offset

ฟังก์ชันนี้คล้ายกับ mad() โดย fma() จะเก็บค่าผลลัพธ์ของการคูณไว้อย่างละเอียดทั้งหมด และปัดเศษหลังจากการบวกเท่านั้น mad() จะปัดเศษหลังจากการคูณและการบวก เราไม่รับประกันความแม่นยำเพิ่มเติมนี้ในโหมด rs_fp_relaxed

fmax : ตัวเลขทศนิยมสูงสุด 2 รายการ

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);	เพิ่มใน API ระดับ 24
half2 fmax(half2 a, half b);	เพิ่มใน API ระดับ 24
half2 fmax(half2 a, half2 b);	เพิ่มใน API ระดับ 24
half3 fmax(half3 a, half b);	เพิ่มใน API ระดับ 24
half3 fmax(half3 a, half3 b);	เพิ่มใน API ระดับ 24
half4 fmax(half4 a, half b);	เพิ่มใน API ระดับ 24
half4 fmax(half4 a, half4 b);	เพิ่มใน API ระดับ 24

แสดงผลค่าสูงสุดของ a และ b ซึ่งก็คือ (a < b ? b : a)

ฟังก์ชัน max() จะแสดงผลลัพธ์ที่เหมือนกัน แต่ใช้ได้กับประเภทข้อมูลมากกว่า

fmin : อย่างน้อย 2 รายการที่เป็นประเภท float

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);	เพิ่มใน API ระดับ 24
half2 fmin(half2 a, half b);	เพิ่มใน API ระดับ 24
half2 fmin(half2 a, half2 b);	เพิ่มใน API ระดับ 24
half3 fmin(half3 a, half b);	เพิ่มใน API ระดับ 24
half3 fmin(half3 a, half3 b);	เพิ่มใน API ระดับ 24
half4 fmin(half4 a, half b);	เพิ่มใน API ระดับ 24
half4 fmin(half4 a, half4 b);	เพิ่มใน API ระดับ 24

แสดงผลค่าต่ำสุดของ a และ b นั่นคือ (a > b ? b : a)

ฟังก์ชัน min() จะแสดงผลลัพธ์ที่เหมือนกัน แต่ใช้ได้กับประเภทข้อมูลมากกว่า

fmod : Modulo

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);	เพิ่มใน API ระดับ 24
half2 fmod(half2 numerator, half2 denominator);	เพิ่มใน API ระดับ 24
half3 fmod(half3 numerator, half3 denominator);	เพิ่มใน API ระดับ 24
half4 fmod(half4 numerator, half4 denominator);	เพิ่มใน API ระดับ 24

แสดงผลลัพธ์ของเศษ (ตัวหาร / ตัวคูณ) โดยที่ผลหารจะปัดเศษเป็น 0

ฟังก์ชัน 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);	เพิ่มใน API ระดับ 24
half fract(half v, half* floor);	เพิ่มใน API ระดับ 24
half2 fract(half2 v);	เพิ่มใน API ระดับ 24
half2 fract(half2 v, half2* floor);	เพิ่มใน API ระดับ 24
half3 fract(half3 v);	เพิ่มใน API ระดับ 24
half3 fract(half3 v, half3* floor);	เพิ่มใน API ระดับ 24
half4 fract(half4 v);	เพิ่มใน API ระดับ 24
half4 fract(half4 v, half4* floor);	เพิ่มใน API ระดับ 24

พารามิเตอร์

v	ค่าอินพุต
ชั้น	หาก floor ไม่ใช่ค่าว่าง ระบบจะตั้งค่า *floor เป็นค่าที่ปัดเศษของ 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);	เพิ่มใน API ระดับ 24
half2 frexp(half2 v, int2* exponent);	เพิ่มใน API ระดับ 24
half3 frexp(half3 v, int3* exponent);	เพิ่มใน API ระดับ 24
half4 frexp(half4 v, int4* exponent);	เพิ่มใน API ระดับ 24

พารามิเตอร์

v	ค่าอินพุต
เลขยกกำลัง	หาก exponent ไม่เท่ากับ Null ระบบจะตั้งค่า *exponent เป็น exponent ของ v

ส่งคืนเศษทศนิยมและตัวคูณของ v แบบไบนารี เช่น v == mantissa * 2 ^ exponent

ส่วนทศนิยมจะอยู่ระหว่าง 0.5 (รวม) ถึง 1.0 (ไม่รวม) เสมอ

ดูการดำเนินการย้อนกลับได้ที่ ldexp() ดูข้อมูลเพิ่มเติมได้ที่ logb() และ ilogb()

half_recip : ผลหารที่คำนวณด้วยความแม่นยำ 16 บิต

float half_recip(float v);	เพิ่มใน API ระดับ 17
float2 half_recip(float2 v);	เพิ่มใน API ระดับ 17
float3 half_recip(float3 v);	เพิ่มใน API ระดับ 17
float4 half_recip(float4 v);	เพิ่มใน API ระดับ 17

แสดงผลค่าประมาณของผลหารย้อนกลับของค่า

ความแม่นยำคือค่าจุดลอยตัว 16 บิต

โปรดดูnative_recip() ด้วย

half_rsqrt : ผลหารของรากที่สองที่คำนวณด้วยความแม่นยำ 16 บิต

float half_rsqrt(float v);	เพิ่มใน API ระดับ 17
float2 half_rsqrt(float2 v);	เพิ่มใน API ระดับ 17
float3 half_rsqrt(float3 v);	เพิ่มใน API ระดับ 17
float4 half_rsqrt(float4 v);	เพิ่มใน API ระดับ 17

แสดงผลค่าโดยประมาณของ (1.f / sqrt(value))

ความแม่นยำคือค่าจุดลอยตัว 16 บิต

ดู rsqrt(), native_rsqrt() เพิ่มเติม

half_sqrt : รากที่สองที่คำนวณด้วยความแม่นยำ 16 บิต

float half_sqrt(float v);	เพิ่มใน API ระดับ 17
float2 half_sqrt(float2 v);	เพิ่มใน API ระดับ 17
float3 half_sqrt(float3 v);	เพิ่มใน API ระดับ 17
float4 half_sqrt(float4 v);	เพิ่มใน API ระดับ 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);	เพิ่มใน API ระดับ 24
half2 hypot(half2 a, half2 b);	เพิ่มใน API ระดับ 24
half3 hypot(half3 a, half3 b);	เพิ่มใน API ระดับ 24
half4 hypot(half4 a, half4 b);	เพิ่มใน API ระดับ 24

แสดงผลด้านตรงข้ามมุมฉาก เช่น sqrt(a * a + b * b)

โปรดดู native_hypot() ด้วย

ilogb : ฐาน 2 ของลําดับชั้น

int ilogb(float v);
int ilogb(half v);	เพิ่มใน API ระดับ 24
int2 ilogb(float2 v);
int2 ilogb(half2 v);	เพิ่มใน API ระดับ 24
int3 ilogb(float3 v);
int3 ilogb(half3 v);	เพิ่มใน API ระดับ 24
int4 ilogb(float4 v);
int4 ilogb(half4 v);	เพิ่มใน API ระดับ 24

แสดงผลเลขชี้กำลังฐาน 2 ของค่า โดยที่ส่วนทศนิยมอยู่ระหว่าง 1.f (รวม) ถึง 2.f (ไม่รวม)

เช่น ilogb(8.5f) จะแสดงผลเป็น 3

เนื่องจากค่าส่วนทศนิยมแตกต่างกัน ตัวเลขนี้จึงน้อยกว่าค่าที่ frexp() แสดงผล 1 หน่วย

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);	เพิ่มใน API ระดับ 24
half2 ldexp(half2 mantissa, int exponent);	เพิ่มใน API ระดับ 24
half2 ldexp(half2 mantissa, int2 exponent);	เพิ่มใน API ระดับ 24
half3 ldexp(half3 mantissa, int exponent);	เพิ่มใน API ระดับ 24
half3 ldexp(half3 mantissa, int3 exponent);	เพิ่มใน API ระดับ 24
half4 ldexp(half4 mantissa, int exponent);	เพิ่มใน API ระดับ 24
half4 ldexp(half4 mantissa, int4 exponent);	เพิ่มใน API ระดับ 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);	เพิ่มใน API ระดับ 24
half lgamma(half v, int* sign_of_gamma);	เพิ่มใน API ระดับ 24
half2 lgamma(half2 v);	เพิ่มใน API ระดับ 24
half2 lgamma(half2 v, int2* sign_of_gamma);	เพิ่มใน API ระดับ 24
half3 lgamma(half3 v);	เพิ่มใน API ระดับ 24
half3 lgamma(half3 v, int3* sign_of_gamma);	เพิ่มใน API ระดับ 24
half4 lgamma(half4 v);	เพิ่มใน API ระดับ 24
half4 lgamma(half4 v, int4* sign_of_gamma);	เพิ่มใน API ระดับ 24

พารามิเตอร์

v
sign_of_gamma	หาก sign_of_gamma ไม่ใช่ค่า Null ระบบจะตั้งค่า *sign_of_gamma เป็น -1.f หาก gamma ของ v เป็นค่าลบ หรือเป็น 1.f หากเป็นค่าบวก

แสดงผลลอการิทึมธรรมชาติของค่าสัมบูรณ์ของฟังก์ชัน Gamma นั่นคือ 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);	เพิ่มใน API ระดับ 24
half2 log(half2 v);	เพิ่มใน API ระดับ 24
half3 log(half3 v);	เพิ่มใน API ระดับ 24
half4 log(half4 v);	เพิ่มใน API ระดับ 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);	เพิ่มใน API ระดับ 24
half2 log10(half2 v);	เพิ่มใน API ระดับ 24
half3 log10(half3 v);	เพิ่มใน API ระดับ 24
half4 log10(half4 v);	เพิ่มใน API ระดับ 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);	เพิ่มใน API ระดับ 24
half2 log1p(half2 v);	เพิ่มใน API ระดับ 24
half3 log1p(half3 v);	เพิ่มใน API ระดับ 24
half4 log1p(half4 v);	เพิ่มใน API ระดับ 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);	เพิ่มใน API ระดับ 24
half2 log2(half2 v);	เพิ่มใน API ระดับ 24
half3 log2(half3 v);	เพิ่มใน API ระดับ 24
half4 log2(half4 v);	เพิ่มใน API ระดับ 24

แสดงผลลอการิทึมฐาน 2

โปรดดู native_log2() ด้วย

logb : ฐาน 2 ของลําดับชั้น

float logb(float v);
float2 logb(float2 v);
float3 logb(float3 v);
float4 logb(float4 v);
half logb(half v);	เพิ่มใน API ระดับ 24
half2 logb(half2 v);	เพิ่มใน API ระดับ 24
half3 logb(half3 v);	เพิ่มใน API ระดับ 24
half4 logb(half4 v);	เพิ่มใน API ระดับ 24

เช่น logb(8.5f) จะแสดงผลเป็น 3.f

เนื่องจากส่วนทศนิยมแตกต่างกัน จำนวนนี้จึงน้อยกว่าค่าที่ frexp() แสดงผล 1 หน่วย

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);	เพิ่มใน API ระดับ 24
half2 mad(half2 multiplicand1, half2 multiplicand2, half2 offset);	เพิ่มใน API ระดับ 24
half3 mad(half3 multiplicand1, half3 multiplicand2, half3 offset);	เพิ่มใน API ระดับ 24
half4 mad(half4 multiplicand1, half4 multiplicand2, half4 offset);	เพิ่มใน API ระดับ 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);	เพิ่มใน API ระดับ 24
half2 max(half2 a, half b);	เพิ่มใน API ระดับ 24
half2 max(half2 a, half2 b);	เพิ่มใน API ระดับ 24
half3 max(half3 a, half b);	เพิ่มใน API ระดับ 24
half3 max(half3 a, half3 b);	เพิ่มใน API ระดับ 24
half4 max(half4 a, half b);	เพิ่มใน API ระดับ 24
half4 max(half4 a, half4 b);	เพิ่มใน API ระดับ 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);	เพิ่มใน API ระดับ 21
long2 max(long2 a, long2 b);	เพิ่มใน API ระดับ 21
long3 max(long3 a, long3 b);	เพิ่มใน API ระดับ 21
long4 max(long4 a, long4 b);	เพิ่มใน API ระดับ 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);	เพิ่มใน API ระดับ 21
ulong2 max(ulong2 a, ulong2 b);	เพิ่มใน API ระดับ 21
ulong3 max(ulong3 a, ulong3 b);	เพิ่มใน API ระดับ 21
ulong4 max(ulong4 a, ulong4 b);	เพิ่มใน API ระดับ 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);

แสดงผลค่าสูงสุดของอาร์กิวเมนต์ 2 รายการ

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);	เพิ่มใน API ระดับ 24
half2 min(half2 a, half b);	เพิ่มใน API ระดับ 24
half2 min(half2 a, half2 b);	เพิ่มใน API ระดับ 24
half3 min(half3 a, half b);	เพิ่มใน API ระดับ 24
half3 min(half3 a, half3 b);	เพิ่มใน API ระดับ 24
half4 min(half4 a, half b);	เพิ่มใน API ระดับ 24
half4 min(half4 a, half4 b);	เพิ่มใน API ระดับ 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);	เพิ่มใน API ระดับ 21
long2 min(long2 a, long2 b);	เพิ่มใน API ระดับ 21
long3 min(long3 a, long3 b);	เพิ่มใน API ระดับ 21
long4 min(long4 a, long4 b);	เพิ่มใน API ระดับ 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);	เพิ่มใน API ระดับ 21
ulong2 min(ulong2 a, ulong2 b);	เพิ่มใน API ระดับ 21
ulong3 min(ulong3 a, ulong3 b);	เพิ่มใน API ระดับ 21
ulong4 min(ulong4 a, ulong4 b);	เพิ่มใน API ระดับ 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);

แสดงผลค่าต่ำสุดของอาร์กิวเมนต์ 2 รายการ

mix : รวม 2 ค่าเข้าด้วยกัน

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);	เพิ่มใน API ระดับ 24
half2 mix(half2 start, half2 stop, half fraction);	เพิ่มใน API ระดับ 24
half2 mix(half2 start, half2 stop, half2 fraction);	เพิ่มใน API ระดับ 24
half3 mix(half3 start, half3 stop, half fraction);	เพิ่มใน API ระดับ 24
half3 mix(half3 start, half3 stop, half3 fraction);	เพิ่มใน API ระดับ 24
half4 mix(half4 start, half4 stop, half fraction);	เพิ่มใน API ระดับ 24
half4 mix(half4 start, half4 stop, half4 fraction);	เพิ่มใน API ระดับ 24

แสดงผลลัพธ์ start + ((stop - start) * fraction)

ซึ่งอาจเป็นประโยชน์สำหรับการผสมค่า 2 ค่า เช่น หากต้องการสร้างสีใหม่โดยผสมสี1 40% กับสี2 60% ให้ใช้ 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);	เพิ่มใน API ระดับ 24
half2 modf(half2 v, half2* integral_part);	เพิ่มใน API ระดับ 24
half3 modf(half3 v, half3* integral_part);	เพิ่มใน API ระดับ 24
half4 modf(half4 v, half4* integral_part);	เพิ่มใน API ระดับ 24

พารามิเตอร์

v	ค่าแหล่งที่มา
integral_part	*integral_part จะมีค่าเป็นจำนวนเต็มของตัวเลข

คิกรีเทิร์น

ส่วนที่เป็นจุดลอยตัวของค่า

แสดงผลส่วนที่เป็นจำนวนเต็มและส่วนที่เป็นทศนิยมของจำนวน

คอมโพเนนต์ทั้ง 2 รายการจะมีเครื่องหมายเดียวกับ x เช่น สําหรับอินพุต -3.72f ระบบจะตั้งค่า *integral_part เป็น -3.f และแสดงผล .72f

nan : ไม่ใช่ตัวเลข

float nan(uint v);

พารามิเตอร์

v	ไม่ใช้

แสดงผลค่า NaN (Not a Number)

nan_half : ไม่ใช่ตัวเลข

half nan_half();

เพิ่มใน API ระดับ 24

แสดงผลค่า NaN (Not a Number) ที่เป็นเลขทศนิยมแบบความแม่นยำครึ่ง

native_acos : โคไซน์ผกผันโดยประมาณ

float native_acos(float v);	เพิ่มใน API ระดับ 21
float2 native_acos(float2 v);	เพิ่มใน API ระดับ 21
float3 native_acos(float3 v);	เพิ่มใน API ระดับ 21
float4 native_acos(float4 v);	เพิ่มใน API ระดับ 21
half native_acos(half v);	เพิ่มใน API ระดับ 24
half2 native_acos(half2 v);	เพิ่มใน API ระดับ 24
half3 native_acos(half3 v);	เพิ่มใน API ระดับ 24
half4 native_acos(half4 v);	เพิ่มใน API ระดับ 24

จะแสดงผลโคไซน์ผกผันโดยประมาณเป็นเรเดียน

ฟังก์ชันนี้จะให้ผลลัพธ์ที่ไม่ระบุจากค่าอินพุตที่น้อยกว่า -1 หรือมากกว่า 1

ดูacos() ด้วย

native_acosh : ฟังก์ชันโคไซน์ไฮเปอร์โบลิกผกผันโดยประมาณ

float native_acosh(float v);	เพิ่มใน API ระดับ 21
float2 native_acosh(float2 v);	เพิ่มใน API ระดับ 21
float3 native_acosh(float3 v);	เพิ่มใน API ระดับ 21
float4 native_acosh(float4 v);	เพิ่มใน API ระดับ 21
half native_acosh(half v);	เพิ่มใน API ระดับ 24
half2 native_acosh(half2 v);	เพิ่มใน API ระดับ 24
half3 native_acosh(half3 v);	เพิ่มใน API ระดับ 24
half4 native_acosh(half4 v);	เพิ่มใน API ระดับ 24

จะแสดงผลค่าโคไซน์ไฮเปอร์โบลิกผกผันโดยประมาณเป็นเรเดียน

โปรดดูacosh() ด้วย

native_acospi : โคไซน์ผกผันโดยประมาณหารด้วย pi

float native_acospi(float v);	เพิ่มใน API ระดับ 21
float2 native_acospi(float2 v);	เพิ่มใน API ระดับ 21
float3 native_acospi(float3 v);	เพิ่มใน API ระดับ 21
float4 native_acospi(float4 v);	เพิ่มใน API ระดับ 21
half native_acospi(half v);	เพิ่มใน API ระดับ 24
half2 native_acospi(half2 v);	เพิ่มใน API ระดับ 24
half3 native_acospi(half3 v);	เพิ่มใน API ระดับ 24
half4 native_acospi(half4 v);	เพิ่มใน API ระดับ 24

แสดงผลโคไซน์ผกผันโดยประมาณเป็นเรเดียน หารด้วยพาย

หากต้องการดูโคไซน์ผกผันซึ่งวัดเป็นองศา ให้ใช้ acospi(a) * 180.f

โปรดดูacospi() ด้วย

native_asin : ฟังก์ชันไซน์ผกผันโดยประมาณ

float native_asin(float v);	เพิ่มใน API ระดับ 21
float2 native_asin(float2 v);	เพิ่มใน API ระดับ 21
float3 native_asin(float3 v);	เพิ่มใน API ระดับ 21
float4 native_asin(float4 v);	เพิ่มใน API ระดับ 21
half native_asin(half v);	เพิ่มใน API ระดับ 24
half2 native_asin(half2 v);	เพิ่มใน API ระดับ 24
half3 native_asin(half3 v);	เพิ่มใน API ระดับ 24
half4 native_asin(half4 v);	เพิ่มใน API ระดับ 24

จะแสดงผลไซน์ผกผันโดยประมาณเป็นเรเดียน

โปรดดูasin() ด้วย

native_asinh : ฟังก์ชันไซน์ไฮเปอร์โบลิกผกผันโดยประมาณ

float native_asinh(float v);	เพิ่มใน API ระดับ 21
float2 native_asinh(float2 v);	เพิ่มใน API ระดับ 21
float3 native_asinh(float3 v);	เพิ่มใน API ระดับ 21
float4 native_asinh(float4 v);	เพิ่มใน API ระดับ 21
half native_asinh(half v);	เพิ่มใน API ระดับ 24
half2 native_asinh(half2 v);	เพิ่มใน API ระดับ 24
half3 native_asinh(half3 v);	เพิ่มใน API ระดับ 24
half4 native_asinh(half4 v);	เพิ่มใน API ระดับ 24

แสดงผลค่าไซน์ไฮเปอร์โบลิกผกผันโดยประมาณเป็นเรเดียน

โปรดดูasinh() ด้วย

native_asinpi : ไซน์ผกผันโดยประมาณหารด้วย pi

float native_asinpi(float v);	เพิ่มใน API ระดับ 21
float2 native_asinpi(float2 v);	เพิ่มใน API ระดับ 21
float3 native_asinpi(float3 v);	เพิ่มใน API ระดับ 21
float4 native_asinpi(float4 v);	เพิ่มใน API ระดับ 21
half native_asinpi(half v);	เพิ่มใน API ระดับ 24
half2 native_asinpi(half2 v);	เพิ่มใน API ระดับ 24
half3 native_asinpi(half3 v);	เพิ่มใน API ระดับ 24
half4 native_asinpi(half4 v);	เพิ่มใน API ระดับ 24

แสดงผลไซน์ผกผันโดยประมาณเป็นเรเดียนหารด้วยพาย

หากต้องการไซน์ผกผันซึ่งวัดเป็นองศา ให้ใช้ asinpi(a) * 180.f

ดูasinpi() เพิ่มเติม

native_atan : ฟังก์ชันตรีโกณผั่วผันแบบประมาณ

float native_atan(float v);	เพิ่มใน API ระดับ 21
float2 native_atan(float2 v);	เพิ่มใน API ระดับ 21
float3 native_atan(float3 v);	เพิ่มใน API ระดับ 21
float4 native_atan(float4 v);	เพิ่มใน API ระดับ 21
half native_atan(half v);	เพิ่มใน API ระดับ 24
half2 native_atan(half2 v);	เพิ่มใน API ระดับ 24
half3 native_atan(half3 v);	เพิ่มใน API ระดับ 24
half4 native_atan(half4 v);	เพิ่มใน API ระดับ 24

จะแสดงผลแทนเจนต์ผกผันโดยประมาณเป็นเรเดียน

ดูatan() เพิ่มเติม

native_atan2 : ฟังก์ชันตรีโกณผั่วผันแบบประมาณของอัตราส่วน

float native_atan2(float numerator, float denominator);	เพิ่มใน API ระดับ 21
float2 native_atan2(float2 numerator, float2 denominator);	เพิ่มใน API ระดับ 21
float3 native_atan2(float3 numerator, float3 denominator);	เพิ่มใน API ระดับ 21
float4 native_atan2(float4 numerator, float4 denominator);	เพิ่มใน API ระดับ 21
half native_atan2(half numerator, half denominator);	เพิ่มใน API ระดับ 24
half2 native_atan2(half2 numerator, half2 denominator);	เพิ่มใน API ระดับ 24
half3 native_atan2(half3 numerator, half3 denominator);	เพิ่มใน API ระดับ 24
half4 native_atan2(half4 numerator, half4 denominator);	เพิ่มใน API ระดับ 24

พารามิเตอร์

ตัวเศษ	ตัวเศษ
ตัวส่วน	ตัวส่วน อาจเป็น 0

ส่งคืนค่าแทนเจนต์ผกผันโดยประมาณของ (numerator / denominator) เป็นเรเดียน

ดู atan2() เพิ่มเติม

native_atan2pi : ฟังก์ชันตรีโกณผั่วผันแบบประมาณของอัตราส่วนหารด้วย pi

float native_atan2pi(float numerator, float denominator);	เพิ่มใน API ระดับ 21
float2 native_atan2pi(float2 numerator, float2 denominator);	เพิ่มใน API ระดับ 21
float3 native_atan2pi(float3 numerator, float3 denominator);	เพิ่มใน API ระดับ 21
float4 native_atan2pi(float4 numerator, float4 denominator);	เพิ่มใน API ระดับ 21
half native_atan2pi(half numerator, half denominator);	เพิ่มใน API ระดับ 24
half2 native_atan2pi(half2 numerator, half2 denominator);	เพิ่มใน API ระดับ 24
half3 native_atan2pi(half3 numerator, half3 denominator);	เพิ่มใน API ระดับ 24
half4 native_atan2pi(half4 numerator, half4 denominator);	เพิ่มใน API ระดับ 24

พารามิเตอร์

ตัวเศษ	ตัวเศษ
ตัวส่วน	ตัวส่วน อาจเป็น 0

ส่งคืนค่าแทนเจนต์ผกผันโดยประมาณของ (numerator / denominator) เป็นเรเดียนหารด้วยพาย

หากต้องการรับค่าแทนเจนต์ผกผันซึ่งวัดเป็นองศา ให้ใช้ atan2pi(n, d) * 180.f

โปรดดู atan2pi() ด้วย

native_atanh : ฟังก์ชันแทนเจนต์ไฮเปอร์โบลิกผกผันโดยประมาณ

float native_atanh(float v);	เพิ่มใน API ระดับ 21
float2 native_atanh(float2 v);	เพิ่มใน API ระดับ 21
float3 native_atanh(float3 v);	เพิ่มใน API ระดับ 21
float4 native_atanh(float4 v);	เพิ่มใน API ระดับ 21
half native_atanh(half v);	เพิ่มใน API ระดับ 24
half2 native_atanh(half2 v);	เพิ่มใน API ระดับ 24
half3 native_atanh(half3 v);	เพิ่มใน API ระดับ 24
half4 native_atanh(half4 v);	เพิ่มใน API ระดับ 24

จะแสดงผลค่าแทนเจนต์ไฮเปอร์โบลิกผกผันโดยประมาณเป็นเรเดียน

โปรดดูatanh() ด้วย

native_atanpi : ฟังก์ชันตรีโกณผนวกผกผันโดยประมาณหารด้วย pi

float native_atanpi(float v);	เพิ่มใน API ระดับ 21
float2 native_atanpi(float2 v);	เพิ่มใน API ระดับ 21
float3 native_atanpi(float3 v);	เพิ่มใน API ระดับ 21
float4 native_atanpi(float4 v);	เพิ่มใน API ระดับ 21
half native_atanpi(half v);	เพิ่มใน API ระดับ 24
half2 native_atanpi(half2 v);	เพิ่มใน API ระดับ 24
half3 native_atanpi(half3 v);	เพิ่มใน API ระดับ 24
half4 native_atanpi(half4 v);	เพิ่มใน API ระดับ 24

แสดงผลแทนเจนต์ผกผันโดยประมาณเป็นเรเดียนหารด้วยพาย

หากต้องการรับค่าแทนเจนต์ผกผันซึ่งวัดเป็นองศา ให้ใช้ atanpi(a) * 180.f

ดู atanpi() เพิ่มเติม

native_cbrt : รากคิวบ์โดยประมาณ

float native_cbrt(float v);	เพิ่มใน API ระดับ 21
float2 native_cbrt(float2 v);	เพิ่มใน API ระดับ 21
float3 native_cbrt(float3 v);	เพิ่มใน API ระดับ 21
float4 native_cbrt(float4 v);	เพิ่มใน API ระดับ 21
half native_cbrt(half v);	เพิ่มใน API ระดับ 24
half2 native_cbrt(half2 v);	เพิ่มใน API ระดับ 24
half3 native_cbrt(half3 v);	เพิ่มใน API ระดับ 24
half4 native_cbrt(half4 v);	เพิ่มใน API ระดับ 24

แสดงผลรากควอดและรากควอดีรัจประมาณ

โปรดดูcbrt() ด้วย

native_cos : โคไซน์โดยประมาณ

float native_cos(float v);	เพิ่มใน API ระดับ 21
float2 native_cos(float2 v);	เพิ่มใน API ระดับ 21
float3 native_cos(float3 v);	เพิ่มใน API ระดับ 21
float4 native_cos(float4 v);	เพิ่มใน API ระดับ 21
half native_cos(half v);	เพิ่มใน API ระดับ 24
half2 native_cos(half2 v);	เพิ่มใน API ระดับ 24
half3 native_cos(half3 v);	เพิ่มใน API ระดับ 24
half4 native_cos(half4 v);	เพิ่มใน API ระดับ 24

ส่งคืนค่าโคไซน์โดยประมาณของมุมที่วัดเป็นเรเดียน

โปรดดูcos() ด้วย

native_cosh : โคไซน์ไฮเปอร์โบลิกโดยประมาณ

float native_cosh(float v);	เพิ่มใน API ระดับ 21
float2 native_cosh(float2 v);	เพิ่มใน API ระดับ 21
float3 native_cosh(float3 v);	เพิ่มใน API ระดับ 21
float4 native_cosh(float4 v);	เพิ่มใน API ระดับ 21
half native_cosh(half v);	เพิ่มใน API ระดับ 24
half2 native_cosh(half2 v);	เพิ่มใน API ระดับ 24
half3 native_cosh(half3 v);	เพิ่มใน API ระดับ 24
half4 native_cosh(half4 v);	เพิ่มใน API ระดับ 24

แสดงผลค่าโคไซน์ไฮเปอร์โบลิกโดยประมาณ

โปรดดูcosh() ด้วย

native_cospi : ค่าประมาณของโคไซน์ของจำนวนที่คูณด้วย pi

float native_cospi(float v);	เพิ่มใน API ระดับ 21
float2 native_cospi(float2 v);	เพิ่มใน API ระดับ 21
float3 native_cospi(float3 v);	เพิ่มใน API ระดับ 21
float4 native_cospi(float4 v);	เพิ่มใน API ระดับ 21
half native_cospi(half v);	เพิ่มใน API ระดับ 24
half2 native_cospi(half2 v);	เพิ่มใน API ระดับ 24
half3 native_cospi(half3 v);	เพิ่มใน API ระดับ 24
half4 native_cospi(half4 v);	เพิ่มใน API ระดับ 24

ส่งคืนค่าโคไซน์โดยประมาณของ (v * pi) โดยที่ (v * pi) จะวัดเป็นเรเดียน

หากต้องการหาโคไซน์ของค่าที่วัดเป็นองศา ให้เรียกใช้ cospi(v / 180.f)

โปรดดู cospi() ด้วย

native_divide : การหารแบบประมาณ

float native_divide(float left_vector, float right_vector);	เพิ่มใน API ระดับ 21
float2 native_divide(float2 left_vector, float2 right_vector);	เพิ่มใน API ระดับ 21
float3 native_divide(float3 left_vector, float3 right_vector);	เพิ่มใน API ระดับ 21
float4 native_divide(float4 left_vector, float4 right_vector);	เพิ่มใน API ระดับ 21
half native_divide(half left_vector, half right_vector);	เพิ่มใน API ระดับ 24
half2 native_divide(half2 left_vector, half2 right_vector);	เพิ่มใน API ระดับ 24
half3 native_divide(half3 left_vector, half3 right_vector);	เพิ่มใน API ระดับ 24
half4 native_divide(half4 left_vector, half4 right_vector);	เพิ่มใน API ระดับ 24

คำนวณการหารค่า 2 ค่าโดยประมาณ

native_exp : ค่าประมาณของ e ยกกำลังเป็นตัวเลข

float native_exp(float v);	เพิ่มใน API ระดับ 18
float2 native_exp(float2 v);	เพิ่มใน API ระดับ 18
float3 native_exp(float3 v);	เพิ่มใน API ระดับ 18
float4 native_exp(float4 v);	เพิ่มใน API ระดับ 18
half native_exp(half v);	เพิ่มใน API ระดับ 24
half2 native_exp(half2 v);	เพิ่มใน API ระดับ 24
half3 native_exp(half3 v);	เพิ่มใน API ระดับ 24
half4 native_exp(half4 v);	เพิ่มใน API ระดับ 24

แสดงเวลาหมดอายุโดยประมาณอย่างรวดเร็ว

ใช้ได้กับอินพุตตั้งแต่ -86.f ถึง 86.f ความแม่นยำจะไม่แย่กว่าที่คาดไว้จากการใช้ค่าจุดลอยตัว 16 บิต

โปรดดู exp() ด้วย

native_exp10 : 10 ยกกำลังเป็นตัวเลขโดยประมาณ

float native_exp10(float v);	เพิ่มใน API ระดับ 18
float2 native_exp10(float2 v);	เพิ่มใน API ระดับ 18
float3 native_exp10(float3 v);	เพิ่มใน API ระดับ 18
float4 native_exp10(float4 v);	เพิ่มใน API ระดับ 18
half native_exp10(half v);	เพิ่มใน API ระดับ 24
half2 native_exp10(half2 v);	เพิ่มใน API ระดับ 24
half3 native_exp10(half3 v);	เพิ่มใน API ระดับ 24
half4 native_exp10(half4 v);	เพิ่มใน API ระดับ 24

exp10 แบบคร่าวๆ ที่รวดเร็ว

ใช้ได้กับอินพุตตั้งแต่ -37.f ถึง 37.f ความแม่นยำจะไม่แย่กว่าที่คาดไว้จากการใช้ค่าจุดลอยตัว 16 บิต

ดู exp10() เพิ่มเติม

native_exp2 : 2 ยกกำลังเป็นจํานวนโดยประมาณ

float native_exp2(float v);	เพิ่มใน API ระดับ 18
float2 native_exp2(float2 v);	เพิ่มใน API ระดับ 18
float3 native_exp2(float3 v);	เพิ่มใน API ระดับ 18
float4 native_exp2(float4 v);	เพิ่มใน API ระดับ 18
half native_exp2(half v);	เพิ่มใน API ระดับ 24
half2 native_exp2(half2 v);	เพิ่มใน API ระดับ 24
half3 native_exp2(half3 v);	เพิ่มใน API ระดับ 24
half4 native_exp2(half4 v);	เพิ่มใน API ระดับ 24

ประมาณ exp2 ที่รวดเร็ว

ใช้ได้กับอินพุตตั้งแต่ -125.f ถึง 125.f ความแม่นยำจะไม่แย่กว่าที่คาดไว้จากการใช้ค่าจุดลอยตัว 16 บิต

ดูข้อมูลเพิ่มเติมได้ที่ exp2()

native_expm1 : ค่าประมาณของ e ยกกำลังด้วยจำนวนลบ 1

float native_expm1(float v);	เพิ่มใน API ระดับ 21
float2 native_expm1(float2 v);	เพิ่มใน API ระดับ 21
float3 native_expm1(float3 v);	เพิ่มใน API ระดับ 21
float4 native_expm1(float4 v);	เพิ่มใน API ระดับ 21
half native_expm1(half v);	เพิ่มใน API ระดับ 24
half2 native_expm1(half2 v);	เพิ่มใน API ระดับ 24
half3 native_expm1(half3 v);	เพิ่มใน API ระดับ 24
half4 native_expm1(half4 v);	เพิ่มใน API ระดับ 24

แสดงผลค่าประมาณ (e ^ v) - 1

ดู expm1() เพิ่มเติม

native_hypot : เส้นทแยงมุมโดยประมาณ

float native_hypot(float a, float b);	เพิ่มใน API ระดับ 21
float2 native_hypot(float2 a, float2 b);	เพิ่มใน API ระดับ 21
float3 native_hypot(float3 a, float3 b);	เพิ่มใน API ระดับ 21
float4 native_hypot(float4 a, float4 b);	เพิ่มใน API ระดับ 21
half native_hypot(half a, half b);	เพิ่มใน API ระดับ 24
half2 native_hypot(half2 a, half2 b);	เพิ่มใน API ระดับ 24
half3 native_hypot(half3 a, half3 b);	เพิ่มใน API ระดับ 24
half4 native_hypot(half4 a, half4 b);	เพิ่มใน API ระดับ 24

แสดงผลค่าประมาณของ native_sqrt(a * a + b * b)

โปรดดูhypot() ด้วย

native_log : ลอการิทึมธรรมชาติโดยประมาณ

float native_log(float v);	เพิ่มใน API ระดับ 18
float2 native_log(float2 v);	เพิ่มใน API ระดับ 18
float3 native_log(float3 v);	เพิ่มใน API ระดับ 18
float4 native_log(float4 v);	เพิ่มใน API ระดับ 18
half native_log(half v);	เพิ่มใน API ระดับ 24
half2 native_log(half2 v);	เพิ่มใน API ระดับ 24
half3 native_log(half3 v);	เพิ่มใน API ระดับ 24
half4 native_log(half4 v);	เพิ่มใน API ระดับ 24

บันทึกโดยประมาณที่รวดเร็ว

แต่จะคลาดเคลื่อนสำหรับค่าที่ใกล้เคียงกับ 0 มาก

โปรดดูlog() ด้วย

native_log10 : ลอการิทึมฐาน 10 โดยประมาณ

float native_log10(float v);	เพิ่มใน API ระดับ 18
float2 native_log10(float2 v);	เพิ่มใน API ระดับ 18
float3 native_log10(float3 v);	เพิ่มใน API ระดับ 18
float4 native_log10(float4 v);	เพิ่มใน API ระดับ 18
half native_log10(half v);	เพิ่มใน API ระดับ 24
half2 native_log10(half2 v);	เพิ่มใน API ระดับ 24
half3 native_log10(half3 v);	เพิ่มใน API ระดับ 24
half4 native_log10(half4 v);	เพิ่มใน API ระดับ 24

ฟังก์ชันหาค่าประมาณของ log10 อย่างรวดเร็ว

แต่จะคลาดเคลื่อนสำหรับค่าที่ใกล้เคียงกับ 0 มาก

ดูข้อมูลเพิ่มเติมได้ที่ log10()

native_log1p : ลอการิทึมธรรมชาติโดยประมาณของค่าบวก 1

float native_log1p(float v);	เพิ่มใน API ระดับ 21
float2 native_log1p(float2 v);	เพิ่มใน API ระดับ 21
float3 native_log1p(float3 v);	เพิ่มใน API ระดับ 21
float4 native_log1p(float4 v);	เพิ่มใน API ระดับ 21
half native_log1p(half v);	เพิ่มใน API ระดับ 24
half2 native_log1p(half2 v);	เพิ่มใน API ระดับ 24
half3 native_log1p(half3 v);	เพิ่มใน API ระดับ 24
half4 native_log1p(half4 v);	เพิ่มใน API ระดับ 24

แสดงผลลอการิทึมธรรมชาติโดยประมาณของ (v + 1.0f)

โปรดดู log1p() ด้วย

native_log2 : ลอการิทึมฐาน 2 โดยประมาณ

float native_log2(float v);	เพิ่มใน API ระดับ 18
float2 native_log2(float2 v);	เพิ่มใน API ระดับ 18
float3 native_log2(float3 v);	เพิ่มใน API ระดับ 18
float4 native_log2(float4 v);	เพิ่มใน API ระดับ 18
half native_log2(half v);	เพิ่มใน API ระดับ 24
half2 native_log2(half2 v);	เพิ่มใน API ระดับ 24
half3 native_log2(half3 v);	เพิ่มใน API ระดับ 24
half4 native_log2(half4 v);	เพิ่มใน API ระดับ 24

ฟังก์ชันหาค่าประมาณของ log2 ที่รวดเร็ว

แต่จะคลาดเคลื่อนสำหรับค่าที่ใกล้เคียงกับ 0 มาก

ดูข้อมูลเพิ่มเติมได้ที่ log2()

native_powr : ฐานบวกโดยประมาณที่ยกกำลัง

float native_powr(float base, float exponent);	เพิ่มใน API ระดับ 18
float2 native_powr(float2 base, float2 exponent);	เพิ่มใน API ระดับ 18
float3 native_powr(float3 base, float3 exponent);	เพิ่มใน API ระดับ 18
float4 native_powr(float4 base, float4 exponent);	เพิ่มใน API ระดับ 18
half native_powr(half base, half exponent);	เพิ่มใน API ระดับ 24
half2 native_powr(half2 base, half2 exponent);	เพิ่มใน API ระดับ 24
half3 native_powr(half3 base, half3 exponent);	เพิ่มใน API ระดับ 24
half4 native_powr(half4 base, half4 exponent);	เพิ่มใน API ระดับ 24

พารามิเตอร์

ฐาน	ต้องอยู่ระหว่าง 0.f ถึง 256.f ฟังก์ชันนี้จะไม่แม่นยำสำหรับค่าที่ใกล้เคียงกับ 0 มาก
เลขยกกำลัง	ต้องอยู่ระหว่าง -15.f ถึง 15.f

ค่าประมาณที่รวดเร็ว (ฐาน ^ ตัวคูณ)

ดูpowr() เพิ่มเติม

native_recip : ผลหารโดยประมาณ

float native_recip(float v);	เพิ่มใน API ระดับ 21
float2 native_recip(float2 v);	เพิ่มใน API ระดับ 21
float3 native_recip(float3 v);	เพิ่มใน API ระดับ 21
float4 native_recip(float4 v);	เพิ่มใน API ระดับ 21
half native_recip(half v);	เพิ่มใน API ระดับ 24
half2 native_recip(half2 v);	เพิ่มใน API ระดับ 24
half3 native_recip(half3 v);	เพิ่มใน API ระดับ 24
half4 native_recip(half4 v);	เพิ่มใน API ระดับ 24

แสดงผลค่าประมาณของผลหารด้วยค่า

ดูข้อมูลเพิ่มเติมได้ที่ half_recip()

native_rootn : ราก n คร่าวๆ

float native_rootn(float v, int n);	เพิ่มใน API ระดับ 21
float2 native_rootn(float2 v, int2 n);	เพิ่มใน API ระดับ 21
float3 native_rootn(float3 v, int3 n);	เพิ่มใน API ระดับ 21
float4 native_rootn(float4 v, int4 n);	เพิ่มใน API ระดับ 21
half native_rootn(half v, int n);	เพิ่มใน API ระดับ 24
half2 native_rootn(half2 v, int2 n);	เพิ่มใน API ระดับ 24
half3 native_rootn(half3 v, int3 n);	เพิ่มใน API ระดับ 24
half4 native_rootn(half4 v, int4 n);	เพิ่มใน API ระดับ 24

คํานวณรากที่ n โดยประมาณของค่า

โปรดดูrootn() ด้วย

native_rsqrt : ค่าประมาณของรากที่สองของจำนวนลบ

float native_rsqrt(float v);	เพิ่มใน API ระดับ 21
float2 native_rsqrt(float2 v);	เพิ่มใน API ระดับ 21
float3 native_rsqrt(float3 v);	เพิ่มใน API ระดับ 21
float4 native_rsqrt(float4 v);	เพิ่มใน API ระดับ 21
half native_rsqrt(half v);	เพิ่มใน API ระดับ 24
half2 native_rsqrt(half2 v);	เพิ่มใน API ระดับ 24
half3 native_rsqrt(half3 v);	เพิ่มใน API ระดับ 24
half4 native_rsqrt(half4 v);	เพิ่มใน API ระดับ 24

แสดงผลค่าประมาณ (1 / sqrt(v))

ดู rsqrt(), half_rsqrt() เพิ่มเติม

native_sin : ไซน์โดยประมาณ

float native_sin(float v);	เพิ่มใน API ระดับ 21
float2 native_sin(float2 v);	เพิ่มใน API ระดับ 21
float3 native_sin(float3 v);	เพิ่มใน API ระดับ 21
float4 native_sin(float4 v);	เพิ่มใน API ระดับ 21
half native_sin(half v);	เพิ่มใน API ระดับ 24
half2 native_sin(half2 v);	เพิ่มใน API ระดับ 24
half3 native_sin(half3 v);	เพิ่มใน API ระดับ 24
half4 native_sin(half4 v);	เพิ่มใน API ระดับ 24

ส่งคืนค่าไซน์โดยประมาณของมุมที่วัดเป็นเรเดียน

โปรดดูsin() ด้วย

native_sincos : ไซน์และโคไซน์โดยประมาณ

float native_sincos(float v, float* cos);	เพิ่มใน API ระดับ 21
float2 native_sincos(float2 v, float2* cos);	เพิ่มใน API ระดับ 21
float3 native_sincos(float3 v, float3* cos);	เพิ่มใน API ระดับ 21
float4 native_sincos(float4 v, float4* cos);	เพิ่มใน API ระดับ 21
half native_sincos(half v, half* cos);	เพิ่มใน API ระดับ 24
half2 native_sincos(half2 v, half2* cos);	เพิ่มใน API ระดับ 24
half3 native_sincos(half3 v, half3* cos);	เพิ่มใน API ระดับ 24
half4 native_sincos(half4 v, half4* cos);	เพิ่มใน API ระดับ 24

พารามิเตอร์

v	ค่าขาเข้าเป็นเรเดียน
cos	*cos จะตั้งค่าเป็นค่าโคไซน์

คิกรีเทิร์น

ไซน์

แสดงผลค่าไซน์และโคไซน์โดยประมาณของค่า

ดูข้อมูลเพิ่มเติมได้ที่ sincos()

native_sinh : ไซน์ไฮเปอร์โบลิกโดยประมาณ

float native_sinh(float v);	เพิ่มใน API ระดับ 21
float2 native_sinh(float2 v);	เพิ่มใน API ระดับ 21
float3 native_sinh(float3 v);	เพิ่มใน API ระดับ 21
float4 native_sinh(float4 v);	เพิ่มใน API ระดับ 21
half native_sinh(half v);	เพิ่มใน API ระดับ 24
half2 native_sinh(half2 v);	เพิ่มใน API ระดับ 24
half3 native_sinh(half3 v);	เพิ่มใน API ระดับ 24
half4 native_sinh(half4 v);	เพิ่มใน API ระดับ 24

แสดงผลค่าไซน์ไฮเปอร์โบลิกโดยประมาณของค่าที่ระบุเป็นเรเดียน

ดูsinh() เพิ่มเติม

native_sinpi : ค่าไซน์โดยประมาณของจำนวนที่คูณด้วย pi

float native_sinpi(float v);	เพิ่มใน API ระดับ 21
float2 native_sinpi(float2 v);	เพิ่มใน API ระดับ 21
float3 native_sinpi(float3 v);	เพิ่มใน API ระดับ 21
float4 native_sinpi(float4 v);	เพิ่มใน API ระดับ 21
half native_sinpi(half v);	เพิ่มใน API ระดับ 24
half2 native_sinpi(half2 v);	เพิ่มใน API ระดับ 24
half3 native_sinpi(half3 v);	เพิ่มใน API ระดับ 24
half4 native_sinpi(half4 v);	เพิ่มใน API ระดับ 24

ส่งคืนค่าไซน์โดยประมาณของ (v * pi) โดยที่ (v * pi) จะวัดเป็นเรเดียน

หากต้องการหาค่าไซน์ของค่าที่วัดเป็นองศา ให้เรียกใช้ sinpi(v / 180.f)

ดูsinpi() เพิ่มเติม

native_sqrt : รากที่สองโดยประมาณ

float native_sqrt(float v);	เพิ่มใน API ระดับ 21
float2 native_sqrt(float2 v);	เพิ่มใน API ระดับ 21
float3 native_sqrt(float3 v);	เพิ่มใน API ระดับ 21
float4 native_sqrt(float4 v);	เพิ่มใน API ระดับ 21
half native_sqrt(half v);	เพิ่มใน API ระดับ 24
half2 native_sqrt(half2 v);	เพิ่มใน API ระดับ 24
half3 native_sqrt(half3 v);	เพิ่มใน API ระดับ 24
half4 native_sqrt(half4 v);	เพิ่มใน API ระดับ 24

แสดงผลค่าประมาณของ sqrt(v)

ดูข้อมูลเพิ่มเติมได้ที่ sqrt(), half_sqrt()

native_tan : ฟังก์ชันแทนเจนต์โดยประมาณ

float native_tan(float v);	เพิ่มใน API ระดับ 21
float2 native_tan(float2 v);	เพิ่มใน API ระดับ 21
float3 native_tan(float3 v);	เพิ่มใน API ระดับ 21
float4 native_tan(float4 v);	เพิ่มใน API ระดับ 21
half native_tan(half v);	เพิ่มใน API ระดับ 24
half2 native_tan(half2 v);	เพิ่มใน API ระดับ 24
half3 native_tan(half3 v);	เพิ่มใน API ระดับ 24
half4 native_tan(half4 v);	เพิ่มใน API ระดับ 24

ส่งคืนค่าแทนเจนต์โดยประมาณของมุมที่วัดเป็นเรเดียน

native_tanh : ไฮเพอร์โบลิกแทนเจนต์โดยประมาณ

float native_tanh(float v);	เพิ่มใน API ระดับ 21
float2 native_tanh(float2 v);	เพิ่มใน API ระดับ 21
float3 native_tanh(float3 v);	เพิ่มใน API ระดับ 21
float4 native_tanh(float4 v);	เพิ่มใน API ระดับ 21
half native_tanh(half v);	เพิ่มใน API ระดับ 24
half2 native_tanh(half2 v);	เพิ่มใน API ระดับ 24
half3 native_tanh(half3 v);	เพิ่มใน API ระดับ 24
half4 native_tanh(half4 v);	เพิ่มใน API ระดับ 24

แสดงผลค่าแทนเจนต์ไฮเปอร์โบลิกโดยประมาณของค่า

โปรดดูtanh() ด้วย

native_tanpi : แทนเจนต์โดยประมาณของจำนวนที่คูณด้วย pi

float native_tanpi(float v);	เพิ่มใน API ระดับ 21
float2 native_tanpi(float2 v);	เพิ่มใน API ระดับ 21
float3 native_tanpi(float3 v);	เพิ่มใน API ระดับ 21
float4 native_tanpi(float4 v);	เพิ่มใน API ระดับ 21
half native_tanpi(half v);	เพิ่มใน API ระดับ 24
half2 native_tanpi(half2 v);	เพิ่มใน API ระดับ 24
half3 native_tanpi(half3 v);	เพิ่มใน API ระดับ 24
half4 native_tanpi(half4 v);	เพิ่มใน API ระดับ 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);	เพิ่มใน API ระดับ 24
half2 nextafter(half2 v, half2 target);	เพิ่มใน API ระดับ 24
half3 nextafter(half3 v, half3 target);	เพิ่มใน API ระดับ 24
half4 nextafter(half4 v, half4 target);	เพิ่มใน API ระดับ 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);	เพิ่มใน API ระดับ 24
half2 pow(half2 base, half2 exponent);	เพิ่มใน API ระดับ 24
half3 pow(half3 base, half3 exponent);	เพิ่มใน API ระดับ 24
half4 pow(half4 base, half4 exponent);	เพิ่มใน API ระดับ 24

แสดงผลฐานที่ยกกำลัง exponent เช่น 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);	เพิ่มใน API ระดับ 24
half2 pown(half2 base, int2 exponent);	เพิ่มใน API ระดับ 24
half3 pown(half3 base, int3 exponent);	เพิ่มใน API ระดับ 24
half4 pown(half4 base, int4 exponent);	เพิ่มใน API ระดับ 24

แสดงผลฐานที่ยกกำลัง exponent เช่น base ^ exponent

pow() และ powr() คล้ายกัน ทั้ง 2 ฟังก์ชันใช้ตัวคูณที่เป็นเลขทศนิยม นอกจากนี้ 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);	เพิ่มใน API ระดับ 24
half2 powr(half2 base, half2 exponent);	เพิ่มใน API ระดับ 24
half3 powr(half3 base, half3 exponent);	เพิ่มใน API ระดับ 24
half4 powr(half4 base, half4 exponent);	เพิ่มใน API ระดับ 24

แสดงผลฐานที่ยกกำลัง exponent เช่น base ^ exponent base ต้องมากกว่าหรือเท่ากับ 0

pow() และ pown() มีความคล้ายกัน ทั้งสองฟังก์ชันไม่ใช้ค่าฐานใดๆ pow() ใช้ตัวคูณที่เป็นทศนิยม ส่วน pown() ใช้จำนวนเต็ม

ดูข้อมูลเพิ่มเติมได้ที่ native_powr()

radians : แปลงองศาเป็นเรเดียน

float radians(float v);
float2 radians(float2 v);
float3 radians(float3 v);
float4 radians(float4 v);
half radians(half v);	เพิ่มใน API ระดับ 24
half2 radians(half2 v);	เพิ่มใน API ระดับ 24
half3 radians(half3 v);	เพิ่มใน API ระดับ 24
half4 radians(half4 v);	เพิ่มใน API ระดับ 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);	เพิ่มใน API ระดับ 24
half2 remainder(half2 numerator, half2 denominator);	เพิ่มใน API ระดับ 24
half3 remainder(half3 numerator, half3 denominator);	เพิ่มใน API ระดับ 24
half4 remainder(half4 numerator, half4 denominator);	เพิ่มใน API ระดับ 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);	เพิ่มใน API ระดับ 24
half2 remquo(half2 numerator, half2 denominator, int2* quotient);	เพิ่มใน API ระดับ 24
half3 remquo(half3 numerator, half3 denominator, int3* quotient);	เพิ่มใน API ระดับ 24
half4 remquo(half4 numerator, half4 denominator, int4* quotient);	เพิ่มใน API ระดับ 24

พารามิเตอร์

ตัวเศษ	ตัวเศษ
ตัวส่วน	ตัวส่วน
ผลหาร	*quotient จะตั้งค่าเป็นผลหารที่เป็นจำนวนเต็ม

คิกรีเทิร์น

เศษ แสดงเฉพาะ 3 บิตล่างสุดที่แน่นอน

แสดงผลลัพธ์หารและเศษของ (ตัวเศษ / ตัวส่วน)

เฉพาะเครื่องหมายและ 3 บิตต่ำสุดของผลหารเท่านั้นที่รับประกันว่าถูกต้อง

ฟังก์ชันนี้มีประโยชน์ในการใช้งานฟังก์ชันตามรอบ 3 บิตล่างของผลหารจะให้ส่วนของแผนภาพ ส่วนเศษเหลือจะเป็นระยะทางภายในส่วนของแผนภาพ เช่น การใช้งาน sin(x) อาจเรียก remquo(x, PI / 2.f, &quadrant) เพื่อลดค่า x ที่มากจนเกินไปให้อยู่ในช่วงที่จำกัด

ตัวอย่างเช่น remquo(-23.5f, 8.f, &quot) จะตั้งค่า 3 บิตต่ำสุดของ 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);	เพิ่มใน API ระดับ 24
half2 rint(half2 v);	เพิ่มใน API ระดับ 24
half3 rint(half3 v);	เพิ่มใน API ระดับ 24
half4 rint(half4 v);	เพิ่มใน API ระดับ 24

ปัดเศษเป็นค่าจำนวนเต็มใกล้ที่สุด

rint() จะปัดค่าครึ่งหนึ่งเป็นค่าคู่ เช่น rint(0.5f) จะแสดงผล 0.f และ rint(1.5f) จะแสดงผล 2.f ในทำนองเดียวกัน rint(-0.5f) จะแสดงผลเป็น -0.f และ rint(-1.5f) จะแสดงผลเป็น -2.f

round() คล้ายกับ ceil() แต่ระบบจะปัดเศษออกจาก 0 trunc() จะตัดทศนิยม

rootn : รากที่ n

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);	เพิ่มใน API ระดับ 24
half2 rootn(half2 v, int2 n);	เพิ่มใน API ระดับ 24
half3 rootn(half3 v, int3 n);	เพิ่มใน API ระดับ 24
half4 rootn(half4 v, int4 n);	เพิ่มใน API ระดับ 24

คํานวณรากที่ n ของค่า

โปรดดูnative_rootn() ด้วย

round : ปัดเศษไม่ให้เป็นศูนย์

float round(float v);
float2 round(float2 v);
float3 round(float3 v);
float4 round(float4 v);
half round(half v);	เพิ่มใน API ระดับ 24
half2 round(half2 v);	เพิ่มใน API ระดับ 24
half3 round(half3 v);	เพิ่มใน API ระดับ 24
half4 round(half4 v);	เพิ่มใน API ระดับ 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);	เพิ่มใน API ระดับ 24
half2 rsqrt(half2 v);	เพิ่มใน API ระดับ 24
half3 rsqrt(half3 v);	เพิ่มใน API ระดับ 24
half4 rsqrt(half4 v);	เพิ่มใน API ระดับ 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);	เพิ่มใน API ระดับ 24
half2 sign(half2 v);	เพิ่มใน API ระดับ 24
half3 sign(half3 v);	เพิ่มใน API ระดับ 24
half4 sign(half4 v);	เพิ่มใน API ระดับ 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);	เพิ่มใน API ระดับ 24
half2 sin(half2 v);	เพิ่มใน API ระดับ 24
half3 sin(half3 v);	เพิ่มใน API ระดับ 24
half4 sin(half4 v);	เพิ่มใน API ระดับ 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);	เพิ่มใน API ระดับ 24
half2 sincos(half2 v, half2* cos);	เพิ่มใน API ระดับ 24
half3 sincos(half3 v, half3* cos);	เพิ่มใน API ระดับ 24
half4 sincos(half4 v, half4* cos);	เพิ่มใน API ระดับ 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);	เพิ่มใน API ระดับ 24
half2 sinh(half2 v);	เพิ่มใน API ระดับ 24
half3 sinh(half3 v);	เพิ่มใน API ระดับ 24
half4 sinh(half4 v);	เพิ่มใน API ระดับ 24

แสดงผลค่าไซน์ไฮเปอร์โบลิกของ v โดยที่ v จะวัดเป็นเรเดียน

โปรดดูnative_sinh() ด้วย

sinpi : ไซน์ของจำนวนที่คูณด้วย pi

float sinpi(float v);
float2 sinpi(float2 v);
float3 sinpi(float3 v);
float4 sinpi(float4 v);
half sinpi(half v);	เพิ่มใน API ระดับ 24
half2 sinpi(half2 v);	เพิ่มใน API ระดับ 24
half3 sinpi(half3 v);	เพิ่มใน API ระดับ 24
half4 sinpi(half4 v);	เพิ่มใน API ระดับ 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);	เพิ่มใน API ระดับ 24
half2 sqrt(half2 v);	เพิ่มใน API ระดับ 24
half3 sqrt(half3 v);	เพิ่มใน API ระดับ 24
half4 sqrt(half4 v);	เพิ่มใน API ระดับ 24

แสดงผลรากที่สองของค่า

ดูข้อมูลเพิ่มเติมได้ที่ half_sqrt(), native_sqrt()

step : 0 หากน้อยกว่าค่าหนึ่งๆ หรือไม่เช่นนั้นจะเป็น 1

float step(float edge, float v);
float2 step(float edge, float2 v);	เพิ่มใน API ระดับ 21
float2 step(float2 edge, float v);
float2 step(float2 edge, float2 v);
float3 step(float edge, float3 v);	เพิ่มใน API ระดับ 21
float3 step(float3 edge, float v);
float3 step(float3 edge, float3 v);
float4 step(float edge, float4 v);	เพิ่มใน API ระดับ 21
float4 step(float4 edge, float v);
float4 step(float4 edge, float4 v);
half step(half edge, half v);	เพิ่มใน API ระดับ 24
half2 step(half edge, half2 v);	เพิ่มใน API ระดับ 24
half2 step(half2 edge, half v);	เพิ่มใน API ระดับ 24
half2 step(half2 edge, half2 v);	เพิ่มใน API ระดับ 24
half3 step(half edge, half3 v);	เพิ่มใน API ระดับ 24
half3 step(half3 edge, half v);	เพิ่มใน API ระดับ 24
half3 step(half3 edge, half3 v);	เพิ่มใน API ระดับ 24
half4 step(half edge, half4 v);	เพิ่มใน API ระดับ 24
half4 step(half4 edge, half v);	เพิ่มใน API ระดับ 24
half4 step(half4 edge, half4 v);	เพิ่มใน API ระดับ 24

แสดงผลเป็น 0.f หาก v < edge หรือแสดงผลเป็น 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);	เพิ่มใน API ระดับ 24
half2 tan(half2 v);	เพิ่มใน API ระดับ 24
half3 tan(half3 v);	เพิ่มใน API ระดับ 24
half4 tan(half4 v);	เพิ่มใน API ระดับ 24

ส่งคืนแทนเจนต์ของมุมที่วัดเป็นเรเดียน

โปรดดูnative_tan() ด้วย

tanh : ฟังก์ชันแทนเจนต์ไฮเปอร์โบลิก

float tanh(float v);
float2 tanh(float2 v);
float3 tanh(float3 v);
float4 tanh(float4 v);
half tanh(half v);	เพิ่มใน API ระดับ 24
half2 tanh(half2 v);	เพิ่มใน API ระดับ 24
half3 tanh(half3 v);	เพิ่มใน API ระดับ 24
half4 tanh(half4 v);	เพิ่มใน API ระดับ 24

แสดงผลค่าแทนเจนต์ไฮเปอร์โบลิกของค่า

โปรดดูnative_tanh() ด้วย

tanpi : แทนเจนต์ของจำนวนที่คูณด้วย pi

float tanpi(float v);
float2 tanpi(float2 v);
float3 tanpi(float3 v);
float4 tanpi(float4 v);
half tanpi(half v);	เพิ่มใน API ระดับ 24
half2 tanpi(half2 v);	เพิ่มใน API ระดับ 24
half3 tanpi(half3 v);	เพิ่มใน API ระดับ 24
half4 tanpi(half4 v);	เพิ่มใน API ระดับ 24

ส่งคืนแทนเจนต์ของ (v * pi) โดยที่ (v * pi) จะวัดเป็นเรเดียน

หากต้องการหาค่าแทนเจนต์ของค่าที่วัดเป็นองศา ให้เรียกใช้ tanpi(v / 180.f)

โปรดดู native_tanpi() ด้วย

tgamma : ฟังก์ชัน Gamma

float tgamma(float v);
float2 tgamma(float2 v);
float3 tgamma(float3 v);
float4 tgamma(float4 v);
half tgamma(half v);	เพิ่มใน API ระดับ 24
half2 tgamma(half2 v);	เพิ่มใน API ระดับ 24
half3 tgamma(half3 v);	เพิ่มใน API ระดับ 24
half4 tgamma(half4 v);	เพิ่มใน API ระดับ 24

แสดงผลฟังก์ชัน Gamma ของค่า

โปรดดู lgamma() ด้วย

trunc : ตัดทศนิยม

float trunc(float v);
float2 trunc(float2 v);
float3 trunc(float3 v);
float4 trunc(float4 v);
half trunc(half v);	เพิ่มใน API ระดับ 24
half2 trunc(half2 v);	เพิ่มใน API ระดับ 24
half3 trunc(half3 v);	เพิ่มใน API ระดับ 24
half4 trunc(half4 v);	เพิ่มใน API ระดับ 24

ปัดเศษเป็นจำนวนเต็มโดยใช้การตัดทอน

เช่น trunc(1.7f) จะแสดงผลเป็น 1.f และ trunc(-1.7f) จะแสดงผลเป็น -1.f

ดูตัวเลือกการปัดเศษอื่นๆ ได้ที่ rint() และ round()