פונקציות וקבועים מתמטיים ב-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, ערכים רגילים חלקית עשויים להימחק לאפס, ועשוי להתבצע עיגול לאפס. לעומת זאת, ב-rs_fp_full נדרש טיפול נכון בערכים קטנים מהרגיל, כלומר ערכים קטנים מ-1.17549435e-38f. בנוסף, ב-rs_fp_rull נדרש עיגול לשבר הקרוב ביותר, עם עיגול למספר זוגי במקרה של שוויון.

אפשר להשיג איזון שונה בין דיוק למהירות באמצעות וריאנטים של פונקציות מתמטיות נפוצות. פונקציות עם שם שמתחיל ב-

  • native_: יכול להיות שיהיו לו הטמעות חומרה בהתאמה אישית עם דיוק נמוך יותר. בנוסף, ייתכן שערכים רגילים חלקית יוסרו ל-0, יתבצע עיגול ל-0 וייתכן שלא תתבצע טיפול נכון בקלט של NaN ושל אינסוף.
  • half_: יכול לבצע חישובים פנימיים באמצעות 16 ביט של פלוט. בנוסף, ייתכן שערכים רגילים למחצה יוסרו לאפס, וייתכן שייעשה שימוש בעיגול לאפס.

סיכום

קבועים
M_1_PI 1 / pi, כמספר ממשי (float) ב-32 ביט
M_2_PI 2 / pi, כמספר ממשי (float) ב-32 ביט
M_2_SQRTPI 2 / sqrt(pi), כמספר ממשי (float) ב-32 ביט
M_E e, כמספר ממשי (float) ב-32 ביט
M_LN10 log_e(10), כמספר ממשי (float) ב-32 ביט
M_LN2 log_e(2), כמספר ממשי (float) של 32 ביט
M_LOG10E log_10(e), כמספר ממשי (float) ב-32 ביט
M_LOG2E log_2(e), כמספר ממשי (float) ב-32 ביט
M_PI pi, כמספר ממשי (float) ב-32 ביט
M_PI_2 pi / 2, כמספר ממשי (float) ב-32 ביט
M_PI_4 pi / 4, כמספר ממשי (float) ב-32 ביט
M_SQRT1_2 1 / sqrt(2), כמספר ממשי (float) ב-32 ביט
M_SQRT2 sqrt(2), כמספר ממשי (float) של 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 e בחזקת מספר מינוס אחד
fabs הערך המוחלט של נקודה צפה
fdim ההפרש החיובי בין שני ערכים
floor המספר השלם הקטן ביותר שלא גדול מערך מסוים
fma כפל והוספה
fmax מקסימום שני מספרים מסוג float
fmin מינימום שני פלוטורים
fmod מודולוס
fract חלק עשרוני חיובי
frexp חזקה וחזקה רגילה בינאריות
half_recip ערכים הופכים לערכים הפוכים ברמת דיוק של 16 ביט
half_rsqrt הופכי של שורש ריבועי שמחושב ברמת דיוק של 16 ביט
half_sqrt שורש ריבועי שמחושב בדיוק של 16 ביט
hypot היפותנוזה
ilogb מעריך בסיס שני
ldexp יצירת נקודה צפה מחזקה וחזקה
lgamma הלוגריתם הטבעי של פונקציית הגאמה
log לוגריתם טבעי
log10 לוגריתם בסיס 10
log1p לוגריתם טבעי של ערך ועוד 1
log2 לוגריתם בבסיס 2
logb מעריך בסיס שני
mad כפל והוספה
max מקסימום
min מינימום
mix מערבב בין שני ערכים
modf רכיבים שלמים וחלקיים
nan Not a Number
nan_half Not a Number
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 בסיס חיובי בחזקת מעריך
רדיאנים המרה של מעלות לרדיאנים
remainder היתרה של חלוקה
remquo שארית ומכפיל של חלוקה
rint עיגול למספר שלם
rootn שורש N
round עיגול הרחק מאפס
rsRand מספר אקראי לכאורה
rsqrt הופכי של שורש ריבועי
sign סימן הערך
sin סינוס
sincos סינוס וקוסינוס
sinh סינוס היפרבולי
sinpi סינוס של מספר כפול פאי
sqrt שורש ריבועי
step 0 אם הערך קטן מ-value, ‏ 1 אחרת
tan טנגנס
tanh טנגנס היפרבולי
tanpi טנגנט של מספר כפול פאי
tgamma פונקציית גאמה
trunc חיתוך של נקודה צפה (floating-point)
פונקציות שהוצאו משימוש
rsClamp הוצא משימוש. הגבלת ערך לטווח
rsFrac הוצא משימוש. הפונקציה מחזירה את החלק השברוני של מספר ממשי.

קבועים

M_1_PI : 1 / pi, כ-float של 32 ביט


ערך: 0.318309886183790671537767526745028724f

הופכי של פאי, כמספר ממשי (float) ב-32 ביט.

M_2_PI : 2 / pi, כערך של 32 ביט


ערך: 0.636619772367581343075535053490057448f

2 חלקי פאי, כמספר ממשי (float) של 32 ביט.

M_2_SQRTPI : 2 / sqrt(pi), כ-float של 32 ביט


ערך: 1.128379167095512573896158903121545172f

2 חלקי שורש הריבועי של פאי, כ-float של 32 ביט.

M_E : e, כמספר ממשי (float) של 32 ביט


ערך: 2.718281828459045235360287471352662498f

המספר e, הבסיס של הלוגריתם הטבעי, כ-float של 32 ביט.

M_LN10 : log_e(10), כ-float של 32 ביט


ערך: 2.302585092994045684017991454684364208f

הלוגריתם הטבעי של 10, כמספר ממשי (float) של 32 ביט.

M_LN2 : log_e(2), כ-float של 32 ביט


ערך: 0.693147180559945309417232121458176568f

הלוגריתם הטבעי של 2, כ-float של 32 ביט.

M_LOG10E : log_10(e), כ-float של 32 ביט


ערך: 0.434294481903251827651128918916605082f

הלוגריתם של e לפי בסיס 10, כערך צף של 32 ביט.

M_LOG2E : log_2(e), כ-float של 32 ביט


ערך: 1.442695040888963407359924681001892137f

הלוגריתם של e לפי בסיס 2, כמספר צף של 32 ביט.

M_PI : pi, כמספר צף של 32 ביט


ערך: 3.141592653589793238462643383279502884f

הקבוע pi, כמספר ממשי (float) של 32 ביט.

M_PI_2 : pi / 2, כערך צף של 32 ביט


ערך: 1.570796326794896619231321691639751442f

פאי חלקי 2, כמספר ממשי (float) של 32 ביט.

M_PI_4 : pi / 4, כ-float של 32 ביט


ערך: 0.785398163397448309615660845819875721f

פאי חלקי 4, כמספר ממשי (float) של 32 ביט.

M_SQRT1_2 : 1 / sqrt(2), כמספר ממשי (float) של 32 ביט


ערך: 0.707106781186547524400844362104849039f

ההופכי של השורש הריבועי של 2, כמספר ממשי (float) של 32 ביט.

M_SQRT2 : sqrt(2), כ-float של 32 ביט


ערך: 1.414213562373095048801688724209698079f

השורש הריבועי של 2, כמספר ממשי (float) של 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);

הפונקציה מחזירה את הערך המוחלט של מספר שלם.

למספרים מסוג float, משתמשים ב-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 : קוסינוס הפוך חלקי פאי

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 : סינוס הפוך חלקי פאי

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 : טנגנט הפוך של יחס, חלקי פאי

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 : טנגנט הפוך חלקי פאי

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

הפונקציה מחזירה את שורש הקובייה.

למידע נוסף, ראו 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.

יש שתי וריאציות של clamp: אחת שבה המינימום והמקסימום הם סקלריים שחלים על כל הרשומות של הערך, והשנייה שבה המינימום והמקסימום הם גם וקטורים.

אם 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

הפונקציה COS מחזירה את הקוסינוס של זווית המבוטאת ברדיאנים.

אפשר גם להיעזר ב-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 : קוסינוס של מספר כפול פאי

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 בחזקת מספר מינוס אחד

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 : ההפרש החיובי בין שני ערכים

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

הפונקציה מחזירה את ההפרש החיובי בין שני ערכים.

אם 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 : מקסימום שני מספרי float

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 : לפחות שני מספרים מסוג 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

הפונקציה מחזירה את השארית של (מנה / מכנה), כאשר החלק השלישי מעוגל לאפס.

הפונקציה 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 הוא לא null, הערך של *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 יוגדר כחזקה של 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

הפונקציה מחזירה את החזקה ההפוכה המשוערת של ערך.

רמת הדיוק היא של ערך נקודה צפה (floating-point) של 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)).

רמת הדיוק היא של ערך נקודה צפה (floating-point) של 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

הפונקציה מחזירה את השורש הריבועי המשוער של ערך.

רמת הדיוק היא של ערך נקודה צפה (floating-point) של 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 : Base two exponent

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

הפונקציה מחזירה את המערך הבסיסי של ערך, כאשר המנטיסה נמצאת בין 1.f (כולל) ל-2.f (לא כולל).

לדוגמה, הפונקציה ilogb(8.5f) מחזירה את הערך 3.

בגלל ההבדל בחזקה, המספר הזה נמוך באחד מהמספר שמוחזר על ידי frexp().

logb() דומה, אבל הפונקציה מחזירה ערך מסוג float.

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.

הפונקציה מחזירה את הלוגריתם הטבעי של הערך המוחלט של פונקציית הגאמה, כלומר 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 : מעריך בסיס שני

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

הפונקציה מחזירה את המערך הבסיסי של ערך, כאשר המנטיסה נמצאת בין 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); נוספה ב-רמת 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);

הפונקציה מחזירה את הערך המקסימלי של שני ארגומנטים.

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);

הפונקציה מחזירה את הערך המינימלי של שני ארגומנטים.

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); נוספה ב-רמת 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).

האפשרות הזו יכולה להיות שימושית כשרוצים לשלב בין שני ערכים. לדוגמה, כדי ליצור צבע חדש שמכיל 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); נוספה ב-רמת 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 יהיה החלק השלם של המספר.
החזרות
החלק של הערך שהוא נקודה צפה.

הפונקציה מחזירה את הרכיבים השלם והשבר של מספר.

לשני הרכיבים יהיה אותו סימן כמו x. לדוגמה, אם מזינים את הערך -3.72f, הערך של *integral_part מוגדר ל--3.f והערך 0 .72f מוחזר.

nan : Not a Number

float nan(uint v);
פרמטרים
vלא בשימוש.

הפונקציה מחזירה ערך NaN (לא מספר).

nan_half : Not a Number

half nan_half();‎ נוספה ב-רמת API 24

הפונקציה מחזירה ערך NaN (Not a Number) של נקודה צפה (floating-point) ברמת דיוק חצי.

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 : קוסינוס הפוך משוער חלקי פאי

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.

הפונקציה הזו מניבה תוצאות לא מוגדרות מערכי קלט שקטנים מ--1 או גדולים מ-1.

למידע נוסף, ראו 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

הפונקציה מחזירה את היפוך הסינוס המשוער, ברדיאנים.

הפונקציה הזו מניבה תוצאות לא מוגדרות מערכי קלט שקטנים מ--1 או גדולים מ-1.

למידע נוסף, ראו 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 : סינוס הפוך משוער חלקי פאי

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.

הפונקציה הזו מניבה תוצאות לא מוגדרות מערכי קלט שקטנים מ--1 או גדולים מ-1.

אפשר גם להיעזר ב-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 : נגזרת קרובה של הטנגנט ההופכי חלקי פאי

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 : קוסינוס משוער של מספר כפול פאי

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

חישוב חלוקה משוערת של שני ערכים.

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. רמת הדיוק לא נמוכה יותר מזו שאפשר לצפות לה כשמשתמשים בערכים של נקודות צפות (floating-point) באורך 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. רמת הדיוק לא נמוכה יותר מזו שאפשר לצפות לה כשמשתמשים בערכים של נקודות צפות (floating-point) באורך 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. רמת הדיוק לא נמוכה יותר מזו שאפשר לצפות לה כשמשתמשים בערכים של נקודות צפות (floating-point) באורך 16 ביט.

למידע נוסף, ראו exp2().

native_expm1 : הערכה של e בחזקת מספר מינוס אחד

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

יומן מהיר עם נתונים משוערים.

היא לא מדויקת לערכים שקרובים מאוד לאפס.

מידע נוסף זמין ב-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 קרובה ומהירה.

היא לא מדויקת לערכים שקרובים מאוד לאפס.

למידע נוסף, ראו 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 משוער.

היא לא מדויקת לערכים שקרובים מאוד לאפס.

למידע נוסף, ראו 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. הפונקציה לא מדויקת עבור ערכים שקרובים מאוד לאפס.
מעריךהערך חייב להיות בין -15.f ל-15.f.

הערכה מהירה (base ^ exponent).

למידע נוסף, ראו 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 : שורש nth משוער

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 : סינוס משוער של מספר כפול פאי

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 : נגזרת קרובה של מספר כפול פאי

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

הפונקציה מחזירה את base לאחר העלאה בחזקה של 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

הפונקציה מחזירה את base לאחר העלאה בחזקה של exponent, כלומר base ^ exponent.

פונקציות pow() ו-powr() דומות. שתי הפונקציות מקבלות מעריך של float. בנוסף, 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

הפונקציה מחזירה את base לאחר העלאה בחזקה של 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 יוגדר כמכנה של המספר השלם.
החזרות
היתרה, מדויקת רק בשלושת הביטים הנמוכים.

הפונקציה מחזירה את מנת החילוק ואת השארית של (מנה / מכנה).

רק הסימן ושלושת הביטים הנמוכים ביותר של החלק היחסי מובטחים להיות מדויקים.

הפונקציה הזו שימושית להטמעת פונקציות תקופתיות. שלושת הביטים הנמוכים של החלק השלישי מסמנים את הרבעון, והשאר מסמנים את המרחק בתוך הרבעון. לדוגמה, הטמעה של sin(x) יכולה להפעיל את remquo(x, PI / 2.f, &quadrant) כדי לצמצם ערך גדול מאוד של x למשהו בטווח מוגבל.

דוגמה: הפונקציה 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); נוספה ב-רמת 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() דומה לפונקציה הזו, אבל היא מעגלת הרחק מהאפס. 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

float rsFrac(float v);‎

הוצא משימוש. במקום זאת, צריך להשתמש בפונקציה fract().

הפונקציה מחזירה את החלק השברוני של מספר שמיוצג כ-float.

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
sign(half4 v) של half4 נוספה ב-רמת 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

הפונקציה SIN מחזירה את הסינוס של זווית המבוטאת ברדיאנים.

אפשר גם להיעזר ב-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 : סינוס של מספר כפול פאי

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 אם הערך קטן מ-value, 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

הפונקציה TGN מחזירה את הטנגנס של זווית המבוטאת ברדיאנים.

אפשר גם להיעזר ב-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 : טנגנט של מספר כפול פאי

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 : פונקציית גאמה

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 מחזירה את פונקציית 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().