instruction_seed stringlengths 43 8.03k | source stringclasses 1
value | embeddings listlengths 1.02k 1.02k | mean_positive_score float64 0.73 0.85 | mean_negative_score float64 0.71 0.82 | difference_score float64 0.01 0.07 |
|---|---|---|---|---|---|
Is there a way to generate a code that finds the largest number in an array of numbers? | glaive | [
0.02836579456925392,
0.035065021365880966,
-0.030552057549357414,
-0.03514381870627403,
0.03544585779309273,
-0.036200325936079025,
-0.019124997779726982,
0.05276060849428177,
0.020303187891840935,
-0.04059753566980362,
0.028715625405311584,
0.04822259396314621,
-0.04905791953206062,
-0.00... | 0.801873 | 0.783789 | 0.018085 |
You are required to create a utility function in ACL2, called `sum-list1`, that takes a list as input and returns the sum of all the elements in the list. The function should use recursion to iterate through the list and calculate the sum. You should also handle the base case where the list is empty.
Your task is to i... | glaive | [
-0.003852587193250656,
0.027832109481096268,
-0.01442424301058054,
-0.0660349503159523,
0.04581766203045845,
-0.02177390642464161,
-0.0058174519799649715,
0.06292732059955597,
0.03501926362514496,
-0.010882294736802578,
0.01928853988647461,
0.045764464884996414,
-0.018465084955096245,
-0.0... | 0.819037 | 0.79374 | 0.025297 |
You are tasked with creating a program that simulates the movement of chess pieces on a chessboard. The specific focus of this problem is on the movement of the rook, bishop, king, and knight.
Your program should be able to do the following:
1. Given a start and end position on the chessboard, determine the number of ... | glaive | [
0.010155814699828625,
0.005843266379088163,
-0.03407961502671242,
-0.02342524193227291,
0.02752700448036194,
-0.019633345305919647,
-0.031131504103541374,
0.05361386388540268,
0.024052778258919716,
-0.034108638763427734,
0.033979833126068115,
0.027765018865466118,
-0.029041921719908714,
-0... | 0.820988 | 0.78454 | 0.036448 |
You are tasked with implementing a CUDA kernel that performs atomic operations on different data types. Your task is to create a kernel called `definitions` that takes in four parameters: an integer pointer `A`, an unsigned integer pointer `B`, an unsigned long long integer pointer `C`, and a float pointer `D`. Within ... | glaive | [
0.017277130857110023,
0.03466222807765007,
-0.0244622640311718,
-0.0033461377024650574,
0.02539367415010929,
-0.03340410441160202,
-0.021687734872102737,
0.10570277273654938,
0.05533074215054512,
-0.01981208473443985,
0.035874832421541214,
0.030823547393083572,
-0.004484960343688726,
0.003... | 0.802544 | 0.787085 | 0.015459 |
You are tasked with creating a CUDA kernel that performs soft thresholding of the detail coefficients in a 2D array. The problem requires you to implement a function that will take as input the detail coefficients in the form of three arrays (c_h, c_v, c_d), a threshold value (beta), and the dimensions of the coefficie... | glaive | [
-0.002019517822191119,
0.026681505143642426,
-0.026795193552970886,
-0.014030689373612404,
0.035458095371723175,
-0.007485612761229277,
-0.03223336115479469,
0.08990410715341568,
0.043128930032253265,
-0.020346852019429207,
0.016263293102383614,
0.05095161497592926,
-0.0015805704751983285,
... | 0.80267 | 0.785639 | 0.01703 |
You are tasked with implementing a SoftmaxWithMaskLayer in C++ using the Caffe framework for deep learning. The SoftmaxWithMaskLayer is a type of layer used in neural networks for classification tasks. It computes the softmax function on a set of input data, along with a mask, and produces the output.
Your task is to ... | glaive | [
0.036429569125175476,
0.026743285357952118,
-0.011017685756087303,
-0.028495367616415024,
0.03260849043726921,
-0.005244570318609476,
-0.036553386598825455,
0.11298339068889618,
0.029613858088850975,
-0.015877418220043182,
0.024167366325855255,
0.03506500646471977,
-0.016952499747276306,
0... | 0.809781 | 0.794564 | 0.015216 |
You are tasked with creating a program to calculate the probability distribution for a quantum system with a given number of qubits and states. The program should take as input the number of qubits, the name of the system, and the number of states. It should then use the provided amplitude and probability functions to ... | glaive | [
0.0006002438603900373,
0.022264376282691956,
-0.03888358920812607,
-0.013463594950735569,
0.03737044334411621,
-0.030607545748353004,
-0.02995217777788639,
0.06247153878211975,
0.027616212144494057,
-0.005393302999436855,
0.02455054596066475,
0.03846687078475952,
-0.017535049468278885,
-0.... | 0.794065 | 0.757833 | 0.036232 |
You are tasked with writing a program in assembly language for the 8086 processor. Your program should display a pattern on the screen using the video memory. The pattern consists of a series of colored bars arranged in a grid. Each bar should be a different color, and the pattern should cover the entire screen. | glaive | [
0.013560518622398376,
0.016972530633211136,
-0.039958078414201736,
-0.021812107414007187,
0.02665887400507927,
-0.027649452909827232,
-0.02636011689901352,
0.08821750432252884,
0.03884226828813553,
-0.025375040248036385,
0.038876283913850784,
0.03718460351228714,
-0.00865144468843937,
-0.0... | 0.797971 | 0.783472 | 0.014499 |
You are tasked with implementing a templated math library for a C++ project. The library needs to provide functions for absolute value, maximum, minimum, ceiling, cosine, exponentiation, flooring, logarithm, power, rounding, sine, square root, and hyperbolic tangent for float, double, and int data types.
You need to ... | glaive | [
0.03423122316598892,
0.02115778438746929,
-0.0338096097111702,
-0.04472632706165314,
0.05569203943014145,
-0.03254733979701996,
-0.025795219466090202,
0.08398124575614929,
0.05192646384239197,
-0.021703124046325684,
0.016114352270960808,
0.042654506862163544,
-0.025291355326771736,
-0.0229... | 0.812864 | 0.788729 | 0.024135 |
You are tasked with implementing a parallel run-length encoding (RLE) algorithm using CUDA. The goal is to efficiently compress a sequence of integers by replacing consecutive repeated values with a single value and a count of how many times it repeats. You will need to implement the following CUDA kernels:
1. `mask`: ... | glaive | [
-0.005778718274086714,
0.05008717253804207,
-0.015081984922289848,
-0.025691330432891846,
0.018789755180478096,
-0.0011192080564796925,
-0.026459241285920143,
0.09625094383955002,
0.02911134622991085,
-0.026642687618732452,
0.027189195156097412,
0.019934263080358505,
0.00146128807682544,
-... | 0.817036 | 0.793824 | 0.023212 |
You are tasked with implementing a set of operations for id sets in Racket. An id set is a set data structure that stores identifiers. The identifiers can be of two types: free and bound. Free identifiers are used in a global scope, while bound identifiers are used in a local scope. The set of operations includes addin... | glaive | [
0.06105829402804375,
0.026649758219718933,
-0.02115279994904995,
-0.001264883205294609,
0.031139792874455452,
-0.02698693424463272,
-0.0077025252394378185,
0.06760994344949722,
0.06981147080659866,
-0.014577013440430164,
0.024312272667884827,
0.01712040789425373,
-0.009113207459449768,
-0.... | 0.802932 | 0.787274 | 0.015657 |
You are tasked with creating a function in F# that takes in a list of integers and returns the sum of all the even numbers in the list. If the input list is empty, the function should return 0.
Write a function called sumEvenNumbers that takes a list of integers and returns the sum of all the even numbers in the list.... | glaive | [
0.027320347726345062,
0.02325165644288063,
-0.029839031398296356,
-0.053822439163923264,
0.04708300158381462,
-0.018794231116771698,
-0.0005557974218390882,
0.04543372243642807,
0.02924700267612934,
-0.015341647900640965,
0.016812609508633614,
0.051890525966882706,
-0.056765783578157425,
-... | 0.809028 | 0.772255 | 0.036772 |
You are working with a dataset that contains the following columns: X, Y, TStamp, Pres., EndPts. Each row in the dataset represents a different set of values for these columns. The DataSize of the dataset is 296. You need to write a program that can read this dataset and perform the following tasks:
1. Calculate the av... | glaive | [
0.004096620716154575,
0.014784234575927258,
-0.04267285391688347,
-0.037590157240629196,
0.03660711646080017,
-0.05756000429391861,
-0.026983849704265594,
0.06823547929525375,
0.05538969114422798,
-0.019557638093829155,
0.042885273694992065,
0.019659729674458504,
-0.0346822664141655,
0.003... | 0.810707 | 0.791941 | 0.018766 |
I am trying to prove that a uniform space is complete provided that it is sequentially complete and its uniformity filter has a countable generating set. I need to show that any Cauchy sequence in the uniform space converges. | glaive | [
0.0022152329329401255,
0.040298547595739365,
-0.04174985736608505,
-0.04838930070400238,
0.015258193016052246,
-0.02522108145058155,
-0.02872413955628872,
0.05807255208492279,
0.020235760137438774,
-0.021410616114735603,
0.01907362788915634,
0.02716047875583172,
-0.017409387975931168,
-0.0... | 0.79377 | 0.77846 | 0.01531 |
You are tasked with implementing a function to calculate the cube root of a given number. The function signature should be as follows:
```zig
pub fn cbrt(x: anytype) @TypeOf(x)
```
The function should return the cube root of the input number `x`. The function should adhere to the following special cases:
- cbrt(+-0) ... | glaive | [
0.02915048785507679,
0.050548337399959564,
-0.033264391124248505,
-0.010599302127957344,
0.043893203139305115,
-0.026611654087901115,
-0.0014492594636976719,
0.059441328048706055,
0.04619623348116875,
-0.014199274592101574,
0.022199317812919617,
0.023182079195976257,
-0.01919952593743801,
... | 0.813771 | 0.798472 | 0.015299 |
You are tasked with creating a module that includes several types and their corresponding equality functions. The types include basic data types such as integers, floats, and strings, as well as more complex types such as lists, options, lazy types, and custom defined types. In addition, there are also examples of mutu... | glaive | [
0.026220299303531647,
0.0218987874686718,
-0.029662057757377625,
-0.030223535373806953,
0.05313119292259216,
-0.049045413732528687,
0.014978541992604733,
0.05710294470191002,
0.04768881946802139,
-0.038167908787727356,
0.029954366385936737,
0.034959279000759125,
-0.019421294331550598,
-0.0... | 0.8028 | 0.784925 | 0.017876 |
You are tasked with creating a program that calculates the day of the week for a given date using the Zeller's Congruence algorithm. The algorithm takes in the year (ano), month (mes), and day (dia) as input, and then calculates the day of the week based on these values. The algorithm involves several mathematical calc... | glaive | [
0.009863907471299171,
0.03712492063641548,
-0.01984715647995472,
-0.02187785692512989,
0.04855784773826599,
-0.033199090510606766,
-0.021731283515691757,
0.05747756361961365,
0.031620945781469345,
-0.029588904231786728,
0.0093686543405056,
0.022976337000727654,
-0.020265677943825722,
0.006... | 0.805079 | 0.776259 | 0.028819 |
I need to write a function that calculates the sum of a series. Specifically, I want to calculate the sum of the series 1 + 1/2 + 1/3 + ... + 1/n. Can anyone help me with that? | glaive | [
0.003701403271406889,
0.0365317277610302,
-0.04871753603219986,
-0.03856934234499931,
0.054129235446453094,
-0.027245942503213882,
-0.03217851370573044,
0.0504569448530674,
0.03845765441656113,
-0.015009758062660694,
0.00963545497506857,
0.013788624666631222,
-0.04237643629312515,
-0.04813... | 0.788108 | 0.769951 | 0.018157 |
You are tasked with implementing a CUDA kernel function to perform a segmented reduction on an input array. The function should take in the input array, the size of the array, an array of segment offsets, the number of segments, an output array, and an operator type. The operator type will specify the type of reduction... | glaive | [
-0.005653559695929289,
0.048285990953445435,
-0.02922941744327545,
-0.02282574400305748,
0.03825072944164276,
-0.01025280449539423,
-0.022748086601495743,
0.09441471099853516,
0.049198709428310394,
0.00809113122522831,
0.03069169633090496,
0.02974945493042469,
-0.007139537017792463,
0.0158... | 0.80538 | 0.783137 | 0.022243 |
You are tasked with creating a program that calculates the probability of a quantum state and then visualizes the results. The program should use the provided amplitude, amplitude2, and probability functions to calculate the probability of a quantum state for a given set of inputs. Once the probability is calculated, t... | glaive | [
-0.00190879893489182,
0.037687595933675766,
-0.029004225507378578,
-0.02389947511255741,
0.04034320265054703,
-0.020859453827142715,
-0.0175003744661808,
0.08410879224538803,
0.043349217623472214,
0.007623837795108557,
0.03180915489792824,
0.04202970862388611,
-0.011078467592597008,
-0.016... | 0.795583 | 0.775292 | 0.020291 |
You are tasked with implementing a kernel using the CUDA framework in C++ to perform a matrix multiplication using the WMMA API. The task involves writing a kernel that takes two input matrices, performs matrix multiplication using the WMMA API, and stores the result in an output matrix.
The kernel should be structure... | glaive | [
0.011972692795097828,
0.04774373769760132,
-0.013519196771085262,
-0.030649123713374138,
0.03536925092339516,
-0.0008245693752542138,
-0.02741260454058647,
0.1145113855600357,
0.04106093943119049,
-0.03254345431923866,
0.01890808716416359,
0.0350605808198452,
-0.008500500582158566,
-0.0083... | 0.79621 | 0.779624 | 0.016586 |
You are tasked with creating a Python program that calculates the factorial of a given number. The factorial of a number n is the product of all positive integers less than or equal to n. Your program should take an integer input from the user and output the factorial of that number. | glaive | [
0.0248422734439373,
0.029675835743546486,
-0.03150637820363045,
-0.029582763090729713,
0.048588868230581284,
-0.03946754336357117,
-0.023619497194886208,
0.03937363997101784,
0.048646409064531326,
-0.020139897242188454,
0.009766224771738052,
0.054402340203523636,
-0.04761090502142906,
-0.0... | 0.801139 | 0.768121 | 0.033018 |
Can you provide a solution to remove duplicate integers from an array while maintaining the original order of elements? | glaive | [
0.023159459233283997,
0.02762569859623909,
-0.029713217169046402,
-0.024555210024118423,
0.02798599749803543,
-0.052102502435445786,
-0.008005489595234394,
0.04764949530363083,
0.03529200330376625,
-0.04047015309333801,
0.014593574218451977,
-0.005516449920833111,
-0.03806048631668091,
-0.... | 0.805773 | 0.789242 | 0.01653 |
You are tasked with implementing a dynamic memory allocation system for the GPU using the given C++ code snippet as a reference. The goal is to create a system that can efficiently allocate and deallocate memory on the GPU. You need to define the necessary data structures and functions to achieve this, ensuring that me... | glaive | [
0.020948614925146103,
0.012525941245257854,
-0.014747721143066883,
-0.025819899514317513,
0.03830869495868683,
-0.04189654067158699,
-0.020178643986582756,
0.09426050633192062,
0.04595761373639107,
-0.023100554943084717,
0.015685690566897392,
0.0402902252972126,
0.00030993547989055514,
0.0... | 0.791008 | 0.771643 | 0.019365 |
You have been tasked with implementing a SparseArray class in Scala that can efficiently store and retrieve data. A SparseArray is an array in which most of the elements have the same value. The class should have the following characteristics:
- It should be generic, supporting any data type.
- It should have a maxSiz... | glaive | [
0.016928410157561302,
0.03419056534767151,
-0.012904624454677105,
-0.03379414603114128,
0.048945192247629166,
-0.03229459375143051,
-0.014216550625860691,
0.05346916988492012,
0.029548881575465202,
-0.0323001854121685,
0.024033254012465477,
0.02377062849700451,
-0.004844739567488432,
0.013... | 0.801614 | 0.776915 | 0.024699 |
You are tasked with creating a program that takes in a series of numbers and organizes them into a specific pattern. The input will be a list of numbers, and the output should be a specific arrangement of those numbers.
The program should take the input list and arrange the numbers in the following pattern:
- The numb... | glaive | [
0.04421789199113846,
0.013816035352647305,
-0.03386804461479187,
-0.02535235695540905,
0.03860204294323921,
-0.01087950263172388,
-0.019464999437332153,
0.04364247992634773,
0.025376705452799797,
0.0008204662008211017,
0.014130097813904285,
0.02822485752403736,
-0.043637681752443314,
-0.00... | 0.824362 | 0.771396 | 0.052966 |
You are tasked with implementing an iterative decomposition algorithm for a given dense system. The algorithm should decompose the system and remove any overall phase. Additionally, you need to check for degeneracy and handle it appropriately. Finally, you must compare the decomposed system with an expected system and ... | glaive | [
0.03211868926882744,
0.011622915975749493,
-0.0293464083224535,
-0.02772671915590763,
0.03940223157405853,
-0.025231482461094856,
-0.022935960441827774,
0.0717269778251648,
0.031153684481978416,
-0.006501047872006893,
0.013690674677491188,
0.018325209617614746,
-0.019318675622344017,
-0.01... | 0.797424 | 0.77796 | 0.019464 |
How can I create a tree from an array of numbers in Python? | glaive | [
0.012160801328718662,
0.02816777676343918,
-0.0364539697766304,
-0.04325466603040695,
0.033766526728868484,
-0.04545901343226433,
0.00285924831405282,
0.04503278061747551,
0.012361370027065277,
-0.035738375037908554,
0.0183896292001009,
0.023771680891513824,
-0.04591066762804985,
0.0039062... | 0.79062 | 0.77398 | 0.01664 |
You are tasked with implementing a heap data structure in Common Lisp. A heap is a specialized tree-based data structure that satisfies the heap property. There are several types of heaps, including binomial, leftist, and fibonacci. Your task is to create a Common Lisp package that provides the following functionality:... | glaive | [
0.018802117556333542,
0.015086033381521702,
-0.03478335589170456,
-0.049867983907461166,
0.0372222475707531,
-0.04665973782539368,
-0.0015482137678191066,
0.07381090521812439,
0.036626365035772324,
-0.03249309957027435,
0.035035330802202225,
0.02017190307378769,
-0.017677174881100655,
-0.0... | 0.802653 | 0.787978 | 0.014675 |
I need to define a procedure called square-tree that takes a tree as input and returns a new tree where each element has been squared. A tree is represented as a list, where each element can be either a number or another list. For example, if the input tree is (list 1 (list 2 (list 3 4) 5) (list 6 7)), the output shoul... | glaive | [
0.027144750580191612,
0.020298631861805916,
-0.05080704018473625,
-0.05332484841346741,
0.039151426404714584,
-0.038743942975997925,
0.0008596481056883931,
0.06954170018434525,
0.03601904213428497,
-0.006817683577537537,
0.03512636944651604,
0.03127557784318924,
-0.052116215229034424,
-0.0... | 0.796574 | 0.772615 | 0.023959 |
You are tasked with implementing a value iteration algorithm for a Markov Decision Process (MDP) using CUDA on an NVIDIA GPU. The value iteration algorithm should compute the optimal value function for each state and the optimal policy for each state. The MDP consists of 'n' states, 'm' actions, and 'ns' successor stat... | glaive | [
0.006289276760071516,
0.018051695078611374,
-0.018247226253151894,
-0.015255010686814785,
0.03852716460824013,
-0.015475057065486908,
-0.03407653048634529,
0.11407724022865295,
0.05346086993813515,
-0.02575291320681572,
0.03791423141956329,
0.028554478660225868,
0.010038630105555058,
-0.00... | 0.797825 | 0.779796 | 0.018029 |
Is it possible to sort an array of numbers in alphabetical order using programming? | glaive | [
0.026967449113726616,
0.009483158588409424,
-0.011578952893614769,
-0.021059110760688782,
0.028021328151226044,
-0.044631149619817734,
-0.009580327197909355,
0.038316838443279266,
0.02087436430156231,
-0.039786722511053085,
0.014163555577397346,
0.023103145882487297,
-0.051797859370708466,
... | 0.794522 | 0.776218 | 0.018304 |
Can you provide an algorithm that prints the Fibonacci sequence up to a specific given number? | glaive | [
0.012980702333152294,
0.022298214957118034,
-0.011898687109351158,
-0.024643413722515106,
0.026315022259950638,
-0.044219307601451874,
-0.026100872084498405,
0.04339765012264252,
0.03547663614153862,
-0.033093977719545364,
0.02937903441488743,
0.048638686537742615,
-0.03779258951544762,
-0... | 0.802612 | 0.782748 | 0.019864 |
You are tasked with implementing a function that calculates the area of a given shape and provides the ability to perform various operations on the shape, such as selecting specific coordinates, adjusting the size, and moving the shape to a new position.
The function should take in the shape's area and an optional sel... | glaive | [
0.011493097990751266,
0.04780525714159012,
-0.035786181688308716,
-0.03052888996899128,
0.048306114971637726,
-0.008032598532736301,
-0.030174385756254196,
0.07413272559642792,
0.04324686899781227,
-0.0012601439375430346,
0.033996667712926865,
0.04186293110251427,
-0.02527685835957527,
-0.... | 0.789144 | 0.771212 | 0.017932 |
Can you provide a formula to calculate compound interest using given values for principal amount, interest rate, time, and compounding frequency? | glaive | [
0.010129365138709545,
0.02924402803182602,
-0.020331023260951042,
-0.03422258794307709,
0.02305884100496769,
-0.037610381841659546,
-0.0055221314541995525,
0.04355408996343613,
0.022973498329520226,
-0.022755373269319534,
0.038805942982435226,
-0.002778589027002454,
-0.04496649280190468,
-... | 0.758208 | 0.743859 | 0.014349 |
You are required to write a program that calculates the probability of a quantum system being in a certain state. The system is described by the amplitude function, which takes two input variables, x and y. The probability of the system being in a certain state is given by the absolute value of the amplitude function s... | glaive | [
0.009617367759346962,
0.025974776595830917,
-0.044820595532655716,
-0.021796269342303276,
0.04631425440311432,
-0.029423415660858154,
-0.025930829346179962,
0.07242172211408615,
0.04036397114396095,
0.001213938812725246,
0.024787671864032745,
0.03285251930356026,
-0.01966768503189087,
-0.0... | 0.809942 | 0.778114 | 0.031828 |
You are tasked with implementing a GPU kernel for calculating the Lennard-Jones forces on particles for the CG-CMM model potential. The goal is to calculate the forces on all N particles using CUDA. The kernel will be called to operate on a block of particles, with each thread calculating the total force on one particl... | glaive | [
0.004085433669388294,
0.05993383005261421,
-0.028087494894862175,
-0.026767294853925705,
0.028051409870386124,
-0.02775261178612709,
-0.04557939991354942,
0.06872161477804184,
0.02990838512778282,
-0.012579197064042091,
0.03580518066883087,
0.04987547546625137,
-0.027604304254055023,
0.003... | 0.80156 | 0.783276 | 0.018284 |
How can I find the maximum and minimum value in an array using Python? | glaive | [
0.011973048560321331,
0.02119864523410797,
-0.03754908964037895,
-0.03455830365419388,
0.03299039974808693,
-0.03677814453840256,
-0.0332457609474659,
0.02128584124147892,
0.024826442822813988,
-0.03188009560108185,
0.02512352727353573,
0.030031131580471992,
-0.03199329599738121,
-0.002978... | 0.788113 | 0.769268 | 0.018845 |
You are tasked with creating a Bayesian logistic regression model to predict the probability of a binary outcome based on a set of predictor variables. The data includes the following:
- N: the number of observations
- n_state: the number of states
- black: a vector of binary values (0 or 1) representing whether the in... | glaive | [
-0.021198105067014694,
0.011148638091981411,
-0.043524254113435745,
-0.04652363806962967,
0.03452626243233681,
-0.018479088321328163,
-0.024367567151784897,
0.07812298834323883,
0.058409687131643295,
0.008189366199076176,
0.0023484353441745043,
0.04439793899655342,
-0.009629607200622559,
0... | 0.783197 | 0.763896 | 0.019301 |
You are tasked with implementing a 2D lattice Boltzmann fluid flow model in Julia. The model simulates fluid flow in a porous random domain, with the size of the simulation grid specified by the user. The lattice Boltzmann method is a powerful tool for simulating complex fluid dynamics, widely used in computational phy... | glaive | [
-0.005551381967961788,
0.0370493158698082,
-0.022851578891277313,
-0.029401132836937904,
0.029707780107855797,
-0.03616451472043991,
-0.04290004447102547,
0.06413797289133072,
0.03597771376371384,
-0.014852101914584637,
0.013315269723534584,
0.03854003921151161,
-0.02238582819700241,
0.001... | 0.787218 | 0.772865 | 0.014353 |
You are required to implement a Prolog module that includes predicates for working with terms and variables. The module should contain the following predicates:
- contains_term/2: Succeeds if the first argument is contained in the second argument
- contains_var/2: Succeeds if the first argument is contained in the seco... | glaive | [
0.019617559388279915,
0.016481565311551094,
-0.03429693728685379,
-0.01985863409936428,
0.03765066713094711,
-0.01993609592318535,
-0.011551715433597565,
0.06069725751876831,
0.01877281256020069,
-0.0011601790320128202,
0.00545263197273016,
0.04107268899679184,
0.007535528391599655,
0.0016... | 0.811416 | 0.791338 | 0.020078 |
Write a program that performs the following mathematical operations using the given operators: addition, subtraction, multiplication, and division.
1. Add the number of days in June and July.
2. Multiply the number of seconds in one hour by 60.
3. Subtract the number of hours between 9am and 3pm from 15.
4. Multiply th... | glaive | [
0.03116927109658718,
0.025471555069088936,
-0.0257884468883276,
-0.02551698498427868,
0.04074493423104286,
-0.026435870677232742,
-0.04824870079755783,
0.07242296636104584,
0.052542515099048615,
-0.007898352108895779,
0.0002638644364196807,
0.020981010049581528,
-0.04645754024386406,
-0.02... | 0.812835 | 0.783679 | 0.029156 |
You are tasked with creating a program that implements Ohm's Law. Ohm's Law states that the current through a conductor between two points is directly proportional to the voltage across the two points. The program should allow the user to choose which unit to convert to (Amps, Volts, or Ohms) and then prompt the user t... | glaive | [
0.0042543308809399605,
0.03278574347496033,
-0.038025662302970886,
-0.04786496236920357,
0.02022537589073181,
-0.061332520097494125,
-0.02284582145512104,
0.05542651191353798,
0.03360417112708092,
-0.012445135973393917,
0.027464760467410088,
0.033492978662252426,
-0.015132129192352295,
-0.... | 0.789494 | 0.772967 | 0.016527 |
How can I find the maximum number among a given set of numbers using JavaScript? | glaive | [
0.01748570241034031,
0.026766730472445488,
-0.02316828817129135,
-0.01858087256550789,
0.03738437220454216,
-0.015335203148424625,
-0.01049227174371481,
0.024039091542363167,
0.02251342311501503,
-0.035944148898124695,
0.024413390085101128,
0.035594187676906586,
-0.05653169006109238,
0.011... | 0.794455 | 0.77596 | 0.018495 |
You are tasked with creating a program that calculates the total cost of a set of items based on their individual prices and quantities. You will be provided with a list of items, each represented by their name, price, and quantity. Your program should iterate through the list and calculate the total cost for each item... | glaive | [
0.009923857636749744,
0.03241764008998871,
-0.044420935213565826,
-0.023008009418845177,
0.04815143719315529,
-0.039953455328941345,
-0.02128782868385315,
0.047068603336811066,
0.04425691068172455,
-0.02097848802804947,
0.03572923317551613,
0.033421579748392105,
-0.03946446254849434,
-0.01... | 0.792369 | 0.770546 | 0.021824 |
You are tasked with creating a program that calculates the number of days between two given dates. Your program should take two input dates in the format (YYYY-MM-DD) and output the number of days between them. You should account for leap years and handle invalid inputs gracefully. Write a function that takes in two da... | glaive | [
-0.00506786722689867,
0.011028931476175785,
-0.04855575039982796,
-0.027106769382953644,
0.04030105844140053,
-0.014012569561600685,
-0.04213721677660942,
0.0712442472577095,
0.0539332777261734,
-0.00832932535558939,
0.021045135334134102,
0.05488600954413414,
-0.016264701262116432,
-0.0110... | 0.791885 | 0.771185 | 0.0207 |
What is the Fibonacci sequence and how can I calculate it using a Python program? | glaive | [
-0.0023571939673274755,
0.02233077958226204,
-0.04187534749507904,
-0.03642039746046066,
0.04713379591703415,
-0.042403481900691986,
-0.02373090572655201,
0.05067293345928192,
0.028124410659074783,
-0.029504522681236267,
0.03123621828854084,
0.05494911968708038,
-0.039441365748643875,
-0.0... | 0.787622 | 0.767248 | 0.020375 |
You have been given a playfield representing a game board, where pieces can be moved from one position to another. Your task is to implement a function that moves a piece on the playfield from a given start square to an end square.
You need to define a function `move_piece` that takes in the playfield, start square, a... | glaive | [
0.023026173934340477,
0.028346074745059013,
-0.027401162311434746,
-0.03507131338119507,
0.038112398236989975,
-0.0208586473017931,
-0.03784353658556938,
0.050140734761953354,
0.030614269897341728,
-0.01970631256699562,
0.04057019576430321,
0.026877326890826225,
-0.04639499634504318,
-0.00... | 0.809939 | 0.781493 | 0.028446 |
You are tasked with creating a program to calculate the probability distribution of a quantum system with a given amplitude function. The amplitude function is defined as follows:
\[amplitude[x,y] := \frac{1}{\sqrt{2^{nqubits}}} \sum_{i=0}^{2^{nqubits}-1} e^{-i y} (f_i(x))\]
Where \(f_i(x)\) is a complex-valued functio... | glaive | [
0.014911619946360588,
0.027272053062915802,
-0.030251478776335716,
-0.0259598009288311,
0.03917374834418297,
-0.0351562425494194,
-0.024947602301836014,
0.06090512126684189,
0.04214518889784813,
0.007063382770866156,
0.02086709998548031,
0.030176647007465363,
-0.022673482075333595,
-0.0250... | 0.798578 | 0.76294 | 0.035638 |
You are tasked with implementing a function in the programming language of your choice that takes a numerical input and returns a corresponding value based on the following equations:
f0 := s -> convert(piecewise(
s < s1, f0_wc(s),
s > s2, f0_rpbe(s),
g(s)*f0_rpbe(s) + (1 - g(s))*f0_wc(s)
), 'Heaviside'):
f ... | glaive | [
0.014347689226269722,
0.040079642087221146,
-0.03975433111190796,
-0.04253167286515236,
0.04403480514883995,
-0.039340902119874954,
-0.018490904942154884,
0.07832234352827072,
0.029559951275587082,
0.0001681941212154925,
0.023481396958231926,
0.04169662669301033,
-0.028770120814442635,
-0.... | 0.833051 | 0.804581 | 0.028471 |
You are tasked with implementing a function to maximize options using a specific algorithm technique. The function should accept the following parameters:
- difficulty level
- algorithm specification
- number of iterations
- logging option
- tracing option
- gradient option
- show step option
- Hessian option
- show to... | glaive | [
0.017303843051195145,
0.006909388117492199,
-0.034950535744428635,
-0.012369670905172825,
0.031373921781778336,
-0.019917424768209457,
-0.021691495552659035,
0.07072025537490845,
0.03719756752252579,
-0.009623213671147823,
0.0197324026376009,
0.034118589013814926,
-0.002859662054106593,
0.... | 0.814079 | 0.787518 | 0.026561 |
You are tasked with implementing a K-Means clustering algorithm using the Twister MapReduce framework. The algorithm aims to cluster a set of data points into a predefined number of clusters, with each map function getting a portion of the data and accessing it split in each iteration. The variable data is the current ... | glaive | [
-0.000607027264777571,
0.035305555909872055,
-0.024781901389360428,
-0.03407824784517288,
0.03808094561100006,
-0.015740210190415382,
-0.024305513128638268,
0.06288188695907593,
0.03953315317630768,
0.0027755293995141983,
0.012683672830462456,
0.0024167532101273537,
-0.01214602217078209,
0... | 0.798237 | 0.774408 | 0.023829 |
What is the function to compute the Fibonacci numbers using recursion? | glaive | [
0.007934685796499252,
0.03953084722161293,
-0.031233005225658417,
-0.03377010300755501,
0.044574007391929626,
-0.016268067061901093,
-0.009282714687287807,
0.056488197296857834,
0.02682066336274147,
-0.01661461591720581,
0.023578770458698273,
0.04057367891073227,
-0.02895643375813961,
-0.0... | 0.806623 | 0.779142 | 0.027481 |
You are tasked with implementing a parallel inclusive scan operation for a given array using CUDA C++ programming. An inclusive scan operation, also known as a prefix sum, computes the cumulative sum of the elements in the array up to a certain position. The code should be able to handle arrays of any size and data typ... | glaive | [
0.001703679678030312,
0.05986157804727554,
-0.010112765245139599,
-0.018886959180235863,
0.03550742566585541,
0.0008518876857124269,
-0.02315354347229004,
0.09538929164409637,
0.042428210377693176,
-0.005826865788549185,
0.02099950611591339,
0.029663775116205215,
0.0015918203862383962,
-0.... | 0.808667 | 0.782003 | 0.026664 |
You are tasked with creating a program to calculate the probability amplitudes and plot the probability distribution of a quantum system. The system is defined by the number of qubits (nqubits), the state name (name), and the number of states (nstates).
The program must include the following functions:
1. amplitude[x_... | glaive | [
-0.0009990151738747954,
0.02547665312886238,
-0.03087794780731201,
-0.022915149107575417,
0.03961900994181633,
-0.03706878423690796,
-0.019646797329187393,
0.06323429197072983,
0.041019733995199203,
0.004396718926727772,
0.020897818729281425,
0.033832330256700516,
-0.022973131388425827,
-0... | 0.789854 | 0.761192 | 0.028661 |
Can you please provide a C# program that prints the first n positive integers? | glaive | [
0.008489923551678658,
0.024238942191004753,
-0.023480601608753204,
-0.023055769503116608,
0.008541087619960308,
-0.047994937747716904,
-0.015270169824361801,
0.06120636314153671,
0.05756261944770813,
-0.03595312684774399,
0.02714512310922146,
0.03229903057217598,
-0.04241745173931122,
-0.0... | 0.809691 | 0.795392 | 0.014299 |
I have an array of numbers and I want to find the maximum number in the array. However, I need to design an algorithm that can solve this problem in linear time. Can someone provide me with a solution? | glaive | [
0.006368198897689581,
0.01665467768907547,
-0.04412319138646126,
-0.02706114389002323,
0.05137341842055321,
-0.029489146545529366,
-0.03244026005268097,
0.05510798096656799,
0.019241906702518463,
-0.02633661776781082,
0.02612103335559368,
0.018668552860617638,
-0.04139246419072151,
-0.0120... | 0.802337 | 0.773365 | 0.028971 |
You are tasked with implementing a program that works with segments and masks in a sparse collection. The program needs to have the following functionalities:
- Clear all segments
- Try to find a segment by its ID and return its index if found
- Remove a segment by its ID and a mask
- Commit any pending changes and rem... | glaive | [
0.03406218811869621,
0.024296611547470093,
-0.032140884548425674,
-0.009518465027213097,
0.03836686164140701,
-0.0406142920255661,
-0.014069882221519947,
0.05625920370221138,
0.03873060271143913,
-0.009348014369606972,
0.029573703184723854,
0.01890821009874344,
-0.003574928967282176,
0.002... | 0.817617 | 0.802984 | 0.014633 |
You are tasked with creating a program that calculates the probability of a quantum state for a given set of qubits. The quantum state is defined by the amplitude function, which takes in two parameters x and y and returns a complex number. The probability of the quantum state is calculated using the absolute value squ... | glaive | [
0.0045729936100542545,
0.03293392062187195,
-0.03645063936710358,
-0.018495116382837296,
0.04723726958036423,
-0.019893230870366096,
-0.015369444154202938,
0.07113206386566162,
0.03596697375178337,
-0.0052888356149196625,
0.024135274812579155,
0.030935317277908325,
-0.014180924743413925,
-... | 0.788494 | 0.755855 | 0.032639 |
You are tasked with proving the commutative property of the logical "and" operator in a programming language that uses the Lean theorem prover. The commutative property states that for any propositions P and Q, if P and Q are both true, then Q and P are also true. Your task is to write a program that uses the introduct... | glaive | [
0.008320670574903488,
0.021662652492523193,
-0.04745590686798096,
-0.04815224930644035,
0.02510058879852295,
-0.01110719982534647,
-0.018009128049016,
0.08260643482208252,
0.03327690064907074,
-0.043748077005147934,
0.014488745480775833,
0.0391155369579792,
-0.027840230613946915,
-0.020565... | 0.810705 | 0.79261 | 0.018095 |
You are tasked with implementing the CGS (Conjugate Gradient Squared) algorithm in CUDA. The algorithm involves several steps, including initialization and multiple iterations. Your goal is to implement the CUDA kernels for each step of the CGS algorithm.
The steps involved are:
1. Initialization: This step involves i... | glaive | [
0.003389386460185051,
0.03434818610548973,
-0.013108835555613041,
-0.014615334570407867,
0.035530369728803635,
-0.026709875091910362,
-0.02392561361193657,
0.08816498517990112,
0.04430925101041794,
-0.02034938521683216,
0.022598112002015114,
0.030860859900712967,
-0.01806452125310898,
0.00... | 0.793566 | 0.774153 | 0.019414 |
Can someone provide a C++ function that can print an integer array in reverse order? | glaive | [
0.02435542270541191,
0.0356377512216568,
-0.018268756568431854,
-0.03532503917813301,
0.025576818734407425,
-0.015250150114297867,
-0.02754286304116249,
0.08612602204084396,
0.04000397026538849,
-0.019025949761271477,
0.02857685461640358,
0.04042161628603935,
-0.042845480144023895,
-0.0283... | 0.802473 | 0.784825 | 0.017648 |
You are tasked with implementing the quick select algorithm to find the median of a given array of boxes. The boxes are represented by a 1D array, with each box having a 2D representation. The median should be calculated based on a specified axis. The algorithm should use insertion sort as the base case for median find... | glaive | [
0.014971572905778885,
0.029652608558535576,
-0.038121942430734634,
-0.029666120186448097,
0.0331527478992939,
-0.020507916808128357,
-0.033743154257535934,
0.06597732752561569,
0.03361685201525688,
-0.005426040850579739,
0.0405447855591774,
0.003996275365352631,
-0.02180800959467888,
-0.00... | 0.810585 | 0.77801 | 0.032575 |
You are given a task to write a function that receives an algebraic expression in the form of a binary tree and decorates this expression by calculating, for each internal node, the value of the parameter ρ and which branch should be evaluated first according to the Ershov algorithm.
The algebraic expressions are repr... | glaive | [
0.029714128002524376,
0.03672390058636665,
-0.02283770963549614,
-0.04909219592809677,
0.03098098188638687,
-0.03405553102493286,
-0.008052567951381207,
0.07167662680149078,
0.05681855231523514,
-0.004027347080409527,
0.03331374749541283,
0.037361059337854385,
-0.035118620842695236,
0.0095... | 0.820323 | 0.787989 | 0.032334 |
You are tasked with creating a string calculator function that takes in a string of numbers separated by delimiters and returns the sum of those numbers. The delimiters can be a single character or a string enclosed in square brackets, and the input string can also specify a custom delimiter using the format "//[delimi... | glaive | [
0.004693001974374056,
0.028249457478523254,
-0.027943706139922142,
-0.03856745734810829,
0.051515307277441025,
-0.043436549603939056,
-0.018903225660324097,
0.0493624173104763,
0.03904680162668228,
-0.014990689232945442,
0.021382126957178116,
0.042844176292419434,
-0.043598394840955734,
-0... | 0.809032 | 0.776386 | 0.032647 |
You are tasked with implementing a function that sorts and retrieves unique values from a given array on a GPU using CUDA. The function should take the following parameters:
1. A resource reference for CUDA computation
2. A pointer to a GPU stream
3. An array of values to be sorted and filtered for uniqueness
4. The nu... | glaive | [
0.010408256202936172,
0.04718407988548279,
-0.01973605901002884,
-0.01638329029083252,
0.02894701063632965,
-0.023855378851294518,
-0.03278610110282898,
0.08657973259687424,
0.05500790849328041,
-0.010530168190598488,
0.027774890884757042,
0.012916559353470802,
0.008256019093096256,
0.0029... | 0.816914 | 0.791168 | 0.025747 |
Can you provide an implementation of an insertion sort algorithm for sorting an array of numbers? | glaive | [
0.03083299659192562,
0.0074875871650874615,
-0.016473518684506416,
-0.02542920783162117,
0.021634606644511223,
-0.028043478727340698,
-0.02142922766506672,
0.0468837134540081,
0.03954411298036575,
-0.03492279350757599,
0.023110371083021164,
0.014490075409412384,
-0.04226049780845642,
-0.01... | 0.805828 | 0.788102 | 0.017726 |
You are tasked with creating a program to calculate and visualize the probability distribution of a quantum state defined by a given amplitude function. The amplitude function is defined as follows:
amplitude[x_,y_] := (complex function with x and y as input parameters)
The probability of finding the state at a speci... | glaive | [
0.009473531506955624,
0.03178338706493378,
-0.03331051394343376,
-0.02708563394844532,
0.035592999309301376,
-0.022524554282426834,
-0.019326746463775635,
0.07281603664159775,
0.044008657336235046,
0.00757939787581563,
0.024031585082411766,
0.030749302357435226,
-0.016190912574529648,
-0.0... | 0.795333 | 0.760411 | 0.034922 |
How can an AI algorithm find the majority element in an array of integers? | glaive | [
0.030478715896606445,
0.02358327992260456,
-0.017928406596183777,
-0.023144593462347984,
0.029657650738954544,
-0.038463469594717026,
-0.02055673487484455,
0.056207120418548584,
0.034220971167087555,
-0.027265779674053192,
0.017867254093289375,
0.027847589924931526,
-0.0065773166716098785,
... | 0.806979 | 0.772615 | 0.034364 |
You are tasked with writing a program that calculates the maximum probability of a given quantum state and then visualizes the probability distribution in 3D and 2D.
The quantum state is defined by the following parameters:
- Number of qubits (nqubits): 16
- Name of the state (name): "16v3 1 1 1 2 3 2 2 1"
- Number of... | glaive | [
0.003948344849050045,
0.0337517224252224,
-0.02823706716299057,
-0.02514822967350483,
0.04729834571480751,
-0.015822937712073326,
-0.013922234997153282,
0.07307127863168716,
0.03378146514296532,
0.012131205759942532,
0.036770015954971313,
0.03795536980032921,
-0.010900209657847881,
-0.0134... | 0.791341 | 0.757098 | 0.034243 |
You are tasked with writing a CUDA kernel to perform matrix multiplication with a vector. The matrix is represented as a 1D array in memory for performance reasons. Each block should calculate a single row in the matrix, and the final result should be stored in a separate array. The kernel should take in the matrix, ve... | glaive | [
0.024129148572683334,
0.0629361942410469,
-0.01654745079576969,
-0.024686487391591072,
0.03744549676775932,
-0.011742963455617428,
-0.040606286376714706,
0.09934467822313309,
0.036334652453660965,
-0.025433816015720367,
0.010661224834620953,
0.02456011064350605,
-0.010738611221313477,
0.00... | 0.788485 | 0.767535 | 0.02095 |
You are tasked with designing a scheduler for a processor, which involves implementing various data structures and types related to the issue queue, active list, op info, and scheduler entries. The problem involves creating the following data structures:
1. Issue Queue: Define the parameters and types related to the i... | glaive | [
0.02406165562570095,
-0.0013454261934384704,
-0.03472745046019554,
-0.013176565058529377,
0.034091778099536896,
-0.032314106822013855,
-0.02501855418086052,
0.07585969567298889,
0.03515631705522537,
-0.008774038404226303,
0.03503846004605293,
0.03139354661107063,
-0.01143126841634512,
0.00... | 0.795805 | 0.776293 | 0.019512 |
You are tasked with implementing the SGEMV subroutine, which performs matrix-vector multiplication with the following operation: y := alpha*A*x + beta*y, or y := alpha*A**T*x + beta*y. You need to write a program that takes in the necessary scalar and array arguments and performs the matrix-vector operation as specifie... | glaive | [
0.026293078437447548,
0.037008076906204224,
-0.028740108013153076,
-0.029999908059835434,
0.05143466219305992,
-0.030033878982067108,
-0.027202939614653587,
0.08195017278194427,
0.029744161292910576,
-0.013438607566058636,
0.006934040691703558,
0.03140639141201973,
-0.02863493748009205,
-0... | 0.793942 | 0.764378 | 0.029564 |
You are tasked with implementing a function that performs vector addition on two arrays of integers. The function should take two arrays of integers, each with a length of 4, and return a new array that contains the result of adding each element from the two input arrays together. You are to write the function from scr... | glaive | [
0.021421825513243675,
0.0395381934940815,
-0.01628311537206173,
-0.02403201349079609,
0.048896074295043945,
0.0007357753929682076,
-0.030490001663565636,
0.07453471422195435,
0.04659537225961685,
-0.012281620875000954,
0.00374551466666162,
0.02237524650990963,
-0.008850928395986557,
-0.021... | 0.811473 | 0.786007 | 0.025466 |
Can you provide an algorithm to determine the maximum number of elements that can be placed in a list without exceeding a given maximum sum? | glaive | [
0.022674348205327988,
0.001748315873555839,
-0.01633458025753498,
-0.031111063435673714,
0.033315472304821014,
-0.03443964570760727,
-0.015465748496353626,
0.028416214510798454,
0.039180103689432144,
-0.04692923650145531,
0.02354433946311474,
0.04984823241829872,
-0.02589590847492218,
-0.0... | 0.803265 | 0.774421 | 0.028844 |
You are tasked with creating a function that takes in a string and generates a shuffled list of characters based on certain criteria. The function should first create a vector of u8 values by hashing the input string using the SHA-512 algorithm. Then, for each u8 value in the vector, the function should perform the fol... | glaive | [
0.006555579137057066,
0.044067904353141785,
0.0004035213205497712,
-0.03799470514059067,
0.04075103625655174,
-0.03270937502384186,
-0.030790116637945175,
0.057080190628767014,
0.03028443083167076,
-0.008522718213498592,
0.016769377514719963,
0.02098262496292591,
-0.030675789341330528,
-0.... | 0.810992 | 0.787138 | 0.023855 |
I need to implement a function that minimizes the trace(S*X) - log det X subject to support(X) ⊆ non_zero_set. The function should take the following input parameters:
- X: a StridedMatrix of AbstractFloat values
- Z: a StridedMatrix of AbstractFloat values
- U: a StridedMatrix of AbstractFloat values
- S: a StridedMat... | glaive | [
0.00989922322332859,
0.026854928582906723,
-0.03764633461833,
-0.026197491213679314,
0.04538755863904953,
-0.03235572203993797,
-0.017075998708605766,
0.06610482931137085,
0.04167814552783966,
-0.012078391388058662,
0.02625664509832859,
0.0214835274964571,
-0.016596851870417595,
-0.0136615... | 0.815222 | 0.799091 | 0.01613 |
You are tasked with creating a program that calculates the probability of a quantum state. The program should take into account the amplitude of the state, which is defined by the function `amplitude[x,y]`, and should then calculate the probability using the formula `Abs[amplitude[x, y]]^2`. The program should also use... | glaive | [
-0.002855919534340501,
0.029701700434088707,
-0.0303775854408741,
-0.017247186973690987,
0.0443478599190712,
-0.020717259496450424,
-0.01204991526901722,
0.07042580097913742,
0.038038212805986404,
0.0022729525808244944,
0.02666991762816906,
0.0360894650220871,
-0.013048449531197548,
-0.014... | 0.784247 | 0.755733 | 0.028514 |
You are tasked with implementing a factorial function in DVM-BASIC. The function should take a positive integer as input and return its factorial value. You should provide two implementations of the factorial function: one using an iterative approach and the other using a recursive approach. The iterative implementatio... | glaive | [
0.020922183990478516,
0.027767764404416084,
-0.021731002256274223,
-0.025385262444615364,
0.029501957818865776,
-0.03005763329565525,
-0.0017367928521707654,
0.060895029455423355,
0.05237570032477379,
0.0007167622679844499,
0.0245220884680748,
0.04080970212817192,
-0.02984723635017872,
0.0... | 0.811082 | 0.778656 | 0.032426 |
You are tasked with implementing a program to calculate the cumulative Laplace distribution with given mean (m) and scale parameter (b) for a given value of x. The program should take input for the mean, scale parameter, and x, and return the cumulative Laplace distribution value.
The domain for the mean (m) is -8e+30... | glaive | [
-0.027570124715566635,
0.043759189546108246,
-0.038128092885017395,
-0.045349594205617905,
0.04567573592066765,
-0.012350884266197681,
-0.030951131135225296,
0.06381583958864212,
0.03521769493818283,
-0.024895919486880302,
0.03816772252321243,
0.053275637328624725,
-0.04108773544430733,
0.... | 0.803198 | 0.770854 | 0.032344 |
You need to implement a single-source shortest path implementation using CUDA based on the work of Harish and Narayanan 2007 "Accelerating Large Graph Algorithms on the GPU Using CUDA" HiPC 2007, LNCS 4873: 197-208.
You are required to create GPU kernels for the following operations:
1. Initiate the mask, cost, and up... | glaive | [
-0.00027058631530962884,
0.05157463997602463,
-0.024523379281163216,
-0.016217537224292755,
0.028489863499999046,
-0.0008311168639920652,
-0.026262763887643814,
0.09569273889064789,
0.03279939666390419,
-0.027757961302995682,
0.030342333018779755,
0.013342475518584251,
0.03221476078033447,
... | 0.800954 | 0.783215 | 0.017738 |
You are tasked with implementing a function to calculate the Kullback-Leibler divergence and the Jensen-Shannon divergence for two probability distributions. The Kullback-Leibler divergence is a measure of how one probability distribution diverges from a second, expected probability distribution. The Jensen-Shannon div... | glaive | [
-0.02325049787759781,
0.02785845845937729,
-0.03465402126312256,
-0.025148073211312294,
0.045108355581760406,
0.00662970170378685,
-0.03213856741786003,
0.06685860455036163,
0.029317157343029976,
0.013715850189328194,
0.011233601719141006,
0.017174985259771347,
-0.006142041180282831,
0.009... | 0.806682 | 0.778586 | 0.028096 |
You are tasked with implementing a CUDA kernel for the Smooth L1 loss function, which is commonly used in machine learning and computer vision tasks. The smooth L1 loss function is defined as follows:
\[L1(x) = \begin{cases}
0.5x^2\sigma^2 & \text{if } |x| < \frac{1}{\sigma^2} \\
|x| - \frac{0.5}{\sigma^2} & \text{ot... | glaive | [
-0.02260994352400303,
0.055626869201660156,
-0.01719142310321331,
-0.03664045035839081,
0.041453249752521515,
-0.004290491808205843,
-0.03760974109172821,
0.09163475781679153,
0.039893586188554764,
-0.02416599541902542,
0.023596031591296196,
0.02898315154016018,
-0.017688024789094925,
-0.0... | 0.802926 | 0.784677 | 0.018249 |
How can I construct an algorithmic method that calculates the lateral surface area and volume of a frustum? The frustum can have either a circular or an elliptical base. The method should be able to process multiple frustums at once, accepting a collection of frustums defined by their individual radii, major and minor ... | glaive | [
-0.004893595352768898,
0.04804385453462601,
-0.02009614370763302,
-0.03512195870280266,
0.018872611224651337,
0.0012860551942139864,
-0.02784431353211403,
0.0633757933974266,
0.007026810199022293,
-0.014123390428721905,
0.033290065824985504,
0.04905928298830986,
-0.009797157719731331,
-0.0... | 0.801554 | 0.782123 | 0.019431 |
You are tasked with creating a program in the Racket programming language that takes a list of numbers as input and returns a new list containing only the even numbers from the original list. Your program should not use any built-in functions for filtering lists. | glaive | [
0.029898015782237053,
0.018865222111344337,
-0.03372897952795029,
-0.03288329765200615,
0.036565493792295456,
-0.019486308097839355,
-0.005084021482616663,
0.046150315552949905,
0.039921827614307404,
-0.0471719391644001,
0.006672171875834465,
0.054936837404966354,
-0.021930478513240814,
-0... | 0.818277 | 0.796433 | 0.021844 |
You are working with an inner product space `E` over `𝕜`, which can be either `ℝ` or `ℂ`. You need to create a function that maps an element `x` of the space to its dual space, `dual 𝕜 E`, using the operation `λ y, ⟪x, y⟫`. This function should also be a conjugate-linear isometric embedding of `E` into `dual 𝕜 E`. A... | glaive | [
0.008225799538195133,
0.03858431801199913,
-0.020568709820508957,
-0.04019877687096596,
0.033988479524850845,
-0.010359024628996849,
0.0024560827296227217,
0.06900540739297867,
0.037543024867773056,
-0.006000631954520941,
0.017226343974471092,
0.03644753247499466,
-0.01126004010438919,
-0.... | 0.815583 | 0.7931 | 0.022483 |
You are tasked with defining a datatype for the language of semiring expressions, implementing the expressions from the laws, and providing a type signature for, and defining, a general evaluator for semiring expressions on the basis of an assignment function. A semiring is a set |R| equipped with two binary operations... | glaive | [
0.01689230278134346,
0.00860658660531044,
-0.038309816271066666,
-0.03038308396935463,
0.04339343309402466,
-0.03669694811105728,
-0.027400467544794083,
0.08326523751020432,
0.05391378700733185,
-0.02161910943686962,
0.025594275444746017,
0.03612302988767624,
-0.0230573657900095,
-0.019036... | 0.79744 | 0.778307 | 0.019133 |
You are tasked with creating a function in MDX (Multi-Dimensional Expressions) that performs the addition of two numeric expressions. The function should take two numeric expressions as input and return the result of their addition. Additionally, the function should handle cases where one or both of the expressions eva... | glaive | [
0.01256137527525425,
0.018808597698807716,
-0.024473415687680244,
-0.05262495577335358,
0.05779793858528137,
0.00893611554056406,
-0.010733632370829582,
0.08210193365812302,
0.0523456372320652,
-0.0006973448907956481,
0.012956595979630947,
0.0339496023952961,
-0.026843814179301262,
-0.0253... | 0.786164 | 0.760671 | 0.025492 |
You are given an array of integers representing the amount of rainfall each day. If it rains on a certain day, the value at that index will be a positive integer representing the amount of rain. If it does not rain, the value will be 0. You need to create a function `avoid_flood` that returns an array of integers. If i... | glaive | [
0.006650921888649464,
0.04311773180961609,
-0.035885073244571686,
-0.02775370515882969,
0.04007285088300705,
-0.06607833504676819,
-0.0232540313154459,
0.07869447022676468,
0.03151547536253929,
-0.01679510809481144,
0.017729036509990692,
0.022736134007573128,
-0.017343485727906227,
-0.0099... | 0.827359 | 0.799062 | 0.028297 |
You are tasked with implementing a subroutine in Fortran called ZLARTG. This subroutine generates a plane rotation so that the input complex numbers F and G are transformed into a real number R, while also calculating the cosine and sine of the rotation. The subroutine should handle different cases based on the values ... | glaive | [
0.003277258248999715,
0.04431695491075516,
-0.025020211935043335,
-0.04732740297913551,
0.0345083549618721,
0.009941873140633106,
-0.008769011124968529,
0.05182116478681564,
0.03176679089665413,
-0.010393882170319557,
0.011597998440265656,
0.03890938311815262,
-0.03394108638167381,
0.01125... | 0.794874 | 0.777586 | 0.017288 |
You are tasked with creating a program that calculates the area of a rectangle. The program should take in the length and width of the rectangle as input from the user, and then output the calculated area. The program should also include error handling to ensure that the input values are valid (i.e., positive numbers). | glaive | [
0.015589293092489243,
0.05144251883029938,
-0.04404701665043831,
-0.029457183554768562,
0.023659897968173027,
-0.018154969438910484,
-0.02518846094608307,
0.05287429690361023,
0.04890437796711922,
-0.013025084510445595,
0.023444902151823044,
0.045963551849126816,
-0.025599803775548935,
-0.... | 0.777655 | 0.749345 | 0.02831 |
You are given a knowledge base containing various classes, properties, and assertions related to the risk factors for Breast Cancer. Your task is to write a program that uses this knowledge base to determine the probability of certain classes being sub-classes of others, based on the given probabilities.
Your program ... | glaive | [
0.007898528128862381,
0.01607677899301052,
-0.037383463233709335,
-0.021537279710173607,
0.04099706932902336,
-0.01798297092318535,
-0.0075145503506064415,
0.07441160082817078,
0.040710560977458954,
-0.004705970641225576,
0.01617325469851494,
0.03340419381856918,
-0.0340411551296711,
0.002... | 0.795145 | 0.773001 | 0.022144 |
You are tasked with implementing a digital race game using VHDL. The game will have two players, and the race will be displayed on a 7-segment display. The game will consist of a start screen, a countdown, the race itself, and game results. The game will also have button press functionality to control the game's progre... | glaive | [
0.00343493465334177,
0.01460456382483244,
-0.01673658937215805,
-0.03192773461341858,
0.015742024406790733,
-0.00674139428883791,
-0.030652310699224472,
0.07187428325414658,
0.04398911073803902,
-0.03568219766020775,
0.016866907477378845,
0.05053192377090454,
0.00047764487680979073,
-0.000... | 0.78882 | 0.768556 | 0.020263 |
You are tasked with implementing a program to simulate a 3D game of life, where cells in a 3D grid evolve over time based on a set of rules. The grid is represented by a field with a specified number of rows, columns, and layers. Each cell in the grid can be in one of two states: alive or dead. The initial state of the... | glaive | [
-0.0002672364062163979,
0.01759897731244564,
-0.02896459773182869,
-0.033891431987285614,
0.0324263833463192,
-0.033021021634340286,
-0.0433846041560173,
0.09888943284749985,
0.0217257309705019,
-0.022463848814368248,
0.029896359890699387,
0.028502225875854492,
-0.05071115866303444,
0.0016... | 0.817786 | 0.786303 | 0.031482 |
You are tasked with implementing a program that calculates the expansion of the given series 1/((1-x)(1-x^2)(1-x^7)). The program should take an input value of x and output the corresponding expansion series. The expansion series should be calculated and printed according to the given formula. | glaive | [
0.02526118978857994,
0.04813029244542122,
-0.050214290618896484,
-0.04916141554713249,
0.043198443949222565,
-0.031017133966088295,
-0.003290965221822262,
0.0738847553730011,
0.05906263366341591,
-0.03155354782938957,
0.02307005599141121,
0.015352770686149597,
-0.050467342138290405,
-0.027... | 0.809282 | 0.775085 | 0.034197 |
You are tasked with implementing a method called "enumerating" that takes in two parameters: aNodeSet (which is a collection of nodes) and a parentAxis (which is a string or block representing the parent axis). The method should create a copy of aNodeSet and populate it with nodes that satisfy the parentAxis condition.... | glaive | [
0.018860194832086563,
0.022504404187202454,
-0.01692843809723854,
-0.020632075145840645,
0.013916507363319397,
-0.01871364191174507,
0.002476585330441594,
0.07988350093364716,
0.03732381388545036,
-0.001354009727947414,
0.017778677865862846,
0.04066735506057739,
-0.04973434656858444,
0.019... | 0.81393 | 0.796118 | 0.017812 |
You are tasked with creating a range partition table on a varchar field, adding a new partition, inserting data into the table, querying all partitions, and finally dropping the table. Assume you have a table named "range_test" with the following columns: id (int), test_int (int), test_char (char), test_varchar (varcha... | glaive | [
0.06006889417767525,
0.014207961037755013,
-0.04901726171374321,
-0.007950615137815475,
0.013255893252789974,
-0.023372817784547806,
-0.010245421901345253,
0.06513823568820953,
0.0320456437766552,
-0.012482814490795135,
0.012238724157214165,
0.023689772933721542,
-0.024255840107798576,
0.0... | 0.784759 | 0.764376 | 0.020383 |
You are tasked with implementing a stable matching cost algorithm using CUDA and OpenCV in C++. The algorithm involves generating a filter mask and then using it to perform stable matching cost calculations on input arrays.
The specific tasks to be completed are as follows:
1. Create a function to generate a filter ma... | glaive | [
0.012117112055420876,
0.040201541036367416,
-0.02409692294895649,
-0.010202499106526375,
0.04449502006173134,
0.008172759786248207,
-0.02084515430033207,
0.10180311650037766,
0.04648516699671745,
-0.04059645161032677,
0.017483027651906013,
0.010625017806887627,
0.010873113758862019,
0.0143... | 0.802883 | 0.780578 | 0.022306 |
You are tasked with creating a program that calculates the probability of a quantum state. The program should include a function to calculate the amplitude of a given input, and another function to calculate the probability based on the amplitude. Additionally, the program should utilize the NMaximize function to find ... | glaive | [
0.002108044223859906,
0.030908411368727684,
-0.029567882418632507,
-0.015476202592253685,
0.05178334191441536,
-0.019372591748833656,
-0.018197892233729362,
0.07384217530488968,
0.03438602387905121,
0.0027306927368044853,
0.028369752690196037,
0.03675973787903786,
-0.018248166888952255,
-0... | 0.791041 | 0.767322 | 0.023719 |
You are tasked with implementing a Lagrange interpolation function in a programming language that supports polynomial operations. The Lagrange interpolation is a method of finding a polynomial that passes through a given set of points.
You need to create a function that takes a finite set `s` and a function `f` mappin... | glaive | [
0.02187991701066494,
0.038241155445575714,
-0.017077187076210976,
-0.04227641224861145,
0.03703716769814491,
-0.03614382445812225,
-0.005738132633268833,
0.05505814775824547,
0.02285216934978962,
-0.02190788835287094,
0.03384283557534218,
0.04281548038125038,
-0.025610167533159256,
0.00817... | 0.814524 | 0.792169 | 0.022355 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.