warp.Function#

class warp.Function(
func,
key,
namespace,
input_types=None,
value_type=None,
value_func=None,
export_func=None,
dispatch_func=None,
lto_dispatch_func=None,
module=None,
variadic=False,
initializer_list_func=None,
export=False,
source=None,
doc='',
group='',
hidden=False,
skip_replay=False,
is_differentiable=True,
generic=False,
native_func=None,
defaults=None,
custom_replay_func=None,
native_snippet=None,
adj_native_snippet=None,
replay_snippet=None,
skip_forward_codegen=False,
skip_reverse_codegen=False,
custom_reverse_num_input_args=-1,
custom_reverse_mode=False,
overloaded_annotations=None,
code_transformers=None,
skip_adding_overload=False,
require_original_output_arg=False,
scope_locals=None,
inline_hint=None,
)[source]#

Represents a Warp function decorated with @warp.func.

Functions can be called from kernels or other Warp functions.

Methods

add_overload(f)

build(builder[, default_builder_options])

call_builtin(desc, *args, **kwargs)

get_builtin(*args, **kwargs)

get_overload(arg_types, kwarg_types)

is_builtin()

is_simple()

mangle()

Build a mangled name for the C-exported function, e.g.: builtin_normalize_vec3().
Parameters:

  • func (Callable | None)

  • key (str)

  • namespace (str)

  • input_types (dict[str, type | TypeVar] | None)

  • value_type (type | None)

  • value_func (Callable[[Mapping[str, type], Mapping[str, Any]], type] | None)

  • export_func (Callable[[dict[str, type]], dict[str, type]] | None)

  • dispatch_func (Callable | None)

  • lto_dispatch_func (Callable | None)

  • module (Module | None)

  • variadic (bool)

  • initializer_list_func (Callable[[dict[str, Any], type], bool] | None)

  • export (bool)

  • source (str | None)

  • doc (str)

  • group (str)

  • hidden (bool)

  • skip_replay (bool)

  • is_differentiable (bool)

  • generic (bool)

  • native_func (str | None)

  • defaults (dict[str, Any] | None)

  • custom_replay_func (Function | None)

  • native_snippet (str | None)

  • adj_native_snippet (str | None)

  • replay_snippet (str | None)

  • skip_forward_codegen (bool)

  • skip_reverse_codegen (bool)

  • custom_reverse_num_input_args (int)

  • custom_reverse_mode (bool)

  • overloaded_annotations (dict[str, type] | None)

  • code_transformers (list[ast.NodeTransformer] | None)

  • skip_adding_overload (bool)

  • require_original_output_arg (bool)

  • scope_locals (dict[str, Any] | None)

  • inline_hint (Literal['noinline', 'forceinline'] | None)

custom_grad_func: Function | None#
user_templates: dict[str, Function]#
user_overloads: dict[str, Function]#
overloads: list[Function]#
mangled_name: str | None#
is_builtin()[source]#
Return type:

bool

is_simple()[source]#
Return type:

bool

mangle()[source]#

Build a mangled name for the C-exported function, e.g.: builtin_normalize_vec3().

Return type:

str

add_overload(f)[source]#
Parameters:

f (Function)

Return type:

None

get_overload(arg_types, kwarg_types)[source]#
Parameters:
Return type:

Function | None

get_builtin(*args, **kwargs)[source]#
Return type:

BuiltinCallDesc

call_builtin(desc, *args, **kwargs)[source]#
Parameters:

desc (BuiltinCallDesc)

Return type:

Any

build(builder, default_builder_options=None)[source]#
Parameters:

builder (ModuleBuilder | None)