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 |
|---|---|---|---|---|---|
You are tasked with implementing a Bayesian decision procedure to classify incoming data into one of two classes based on the observed features. The goal is to minimize the expected loss incurred by the decision procedure. The loss matrix for the decision problem is given by:
\[ \begin{matrix}
& \text{Class 1} & \te... | glaive | [
-0.012498178519308567,
-0.0013923655496910214,
-0.059031832963228226,
-0.02887451834976673,
0.04770703241229057,
-0.026570776477456093,
-0.01918211579322815,
0.0757574811577797,
0.03841850906610489,
-0.004484382923692465,
0.02175997756421566,
0.03146631643176079,
-0.0025916153099387884,
-0... | 0.801382 | 0.779126 | 0.022256 |
How can I create a Python function that identifies the index of a "boundary" element in a list of integers? A boundary element is defined as an element where the product of all elements to the left is equal to the geometric mean of the elements to the right.
```python
lst = [2, 3, 8, -1, -2, 6]
``` | glaive | [
0.03620950132608414,
0.020922578871250153,
-0.035595931112766266,
-0.03925838693976402,
0.044439125806093216,
-0.03389756754040718,
-0.027065634727478027,
0.050548255443573,
0.04433877766132355,
-0.010710146278142929,
0.01986742578446865,
0.050966303795576096,
-0.03315988555550575,
-0.0160... | 0.799526 | 0.783163 | 0.016363 |
You are tasked with implementing the Dijkstra algorithm to find the shortest path from a given start node to all other nodes in a graph. The graph is represented by a set of nodes and edges, with each edge having a cost associated with it. The Dijkstra algorithm works by visiting all nodes in the graph and updating the... | glaive | [
0.003450935473665595,
0.013237321749329567,
-0.03186936676502228,
-0.02888059802353382,
0.04037221148610115,
-0.016093775629997253,
-0.02043122798204422,
0.06186959892511368,
0.05734315887093544,
-0.011580108664929867,
0.030295852571725845,
0.02722620964050293,
-0.006468590348958969,
-0.00... | 0.809512 | 0.776099 | 0.033414 |
You are tasked with implementing a method that calculates the intersection of two timeline masks and returns the result. The timeline masks are represented as objects of the class `TimelineMask` and the intersections are calculated using the `&` and `~` operators. The method should be able to handle various scenarios s... | glaive | [
0.04183424264192581,
0.01864037662744522,
-0.014583339914679527,
-0.024854086339473724,
0.047212421894073486,
-0.008752851746976376,
-0.02032781019806862,
0.06448272615671158,
0.04831165820360184,
-0.0040910388343036175,
0.02960706502199173,
0.02062453329563141,
-0.003512443508952856,
-0.0... | 0.80381 | 0.785172 | 0.018638 |
I am trying to create a function that takes an array as input and returns a new array containing the first and last elements of the input array. The function should remove the first and last elements from the original array and return them as a new array.
For example, if the input array is [7, 14, "olá"], the function... | glaive | [
0.02463320456445217,
0.048712749034166336,
-0.037932850420475006,
-0.04410110041499138,
0.04277017340064049,
-0.04666038230061531,
-0.03329635411500931,
0.06518430262804031,
0.030114995315670967,
-0.019520657137036324,
0.021520059555768967,
0.0035927409771829844,
-0.03566966950893402,
-0.0... | 0.790435 | 0.771249 | 0.019186 |
You are required to implement a function that performs various operations on word types in a programming language that supports word operations. The function should be able to perform operations such as bit manipulation, concatenation, conversion between different representations (binary, decimal, hex, octal), comparis... | glaive | [
0.02266455627977848,
0.03387956693768501,
-0.010363716632127762,
-0.03313473239541054,
0.03470369800925255,
-0.034368108958005905,
-0.027390118688344955,
0.060493092983961105,
0.05322388932108879,
-0.01847529411315918,
0.023817749693989754,
0.03200209140777588,
-0.0076967221684753895,
-0.0... | 0.805267 | 0.786544 | 0.018723 |
Write a function to find the unique rows in a given matrix and return a sorted, unique list. The function should also be able to return the unique list with frequency counts if needed. The input matrix can be of any type (integer, string, etc.) and the function should be able to handle it accordingly. The function shou... | glaive | [
0.02083425037562847,
0.03702737018465996,
-0.033966731280088425,
-0.031547773629426956,
0.04517121985554695,
-0.028413236141204834,
-0.020585132762789726,
0.06520448625087738,
0.05542495846748352,
-0.007819494232535362,
0.010257710702717304,
0.010702071711421013,
-0.013553863391280174,
-0.... | 0.808286 | 0.776552 | 0.031734 |
You are tasked with creating a C++ class that implements a solver for the Algebraic Multigrid (AMG) method. The class should be able to set up the AMG system with a given matrix A and solve the system Ax=b. The class should also be able to retrieve the number of iterations taken to solve the system.
Your task is to im... | glaive | [
0.042207881808280945,
-0.007586074993014336,
-0.025624392554163933,
-0.0329301580786705,
0.040193457156419754,
-0.0349523164331913,
-0.02734559401869774,
0.09494777768850327,
0.044908419251441956,
-0.010228264145553112,
0.014392942190170288,
0.04101607948541641,
-0.012297905050218105,
0.00... | 0.807563 | 0.786644 | 0.020918 |
You are tasked with implementing a k-truss algorithm for a given graph in C++ using the TiledCOOCSRGraph framework. The k-truss algorithm aims to find all the triangles in a graph where each edge is part of at least k-2 triangles. The algorithm involves counting triangles, marking deleted edges, and identifying affecte... | glaive | [
0.021232640370726585,
0.027460645884275436,
-0.012585609219968319,
-0.030712075531482697,
0.03182922676205635,
-0.015410786494612694,
-0.017588885501027107,
0.08117050677537918,
0.03360235318541527,
0.0011310597183182836,
0.024504370987415314,
0.018306421115994453,
-0.0026789905969053507,
... | 0.817776 | 0.781178 | 0.036598 |
You are tasked with calculating the probability of a quantum state for a given set of parameters. The quantum state is defined by the `amplitude` function, and the probability is calculated using the `probability` function. The goal is to find the maximum probability for a specific number of states within a certain ran... | glaive | [
-0.0038585399743169546,
0.04392452538013458,
-0.021870771422982216,
-0.019291149452328682,
0.04403657838702202,
-0.01599995791912079,
-0.017658628523349762,
0.07639091461896896,
0.021640989929437637,
0.01686124876141548,
0.018314359709620476,
0.034679315984249115,
-0.007025111932307482,
-0... | 0.792308 | 0.755298 | 0.03701 |
You are tasked with implementing a Verilog module that calculates the transpose of a given matrix. The module should have the following functionality:
- It should take a matrix A of dimensions M by N as input.
- It should have ports for clk (clock signal) and reset (system reset, low asserted).
- It should generate a ... | glaive | [
0.034812405705451965,
0.0273587629199028,
-0.02809946797788143,
-0.0420483760535717,
0.032587483525276184,
-0.02950555458664894,
-0.015171467326581478,
0.06844617426395416,
0.03231734782457352,
-0.01565437763929367,
0.030718786641955376,
0.04041479900479317,
-0.015622895210981369,
-0.00037... | 0.79385 | 0.776508 | 0.017342 |
You are tasked with creating a function that generates a random string based on certain criteria. The function should take in three parameters: min, max, and type. The min and max parameters determine the length of the string to be generated, while the type parameter dictates the type of characters to be included in th... | glaive | [
0.001072065788321197,
0.022295504808425903,
-0.0038741857279092073,
-0.035859085619449615,
0.02943386696279049,
-0.04387584328651428,
-0.02762865275144577,
0.051570262759923935,
0.03177604451775551,
-0.015448886901140213,
0.037032514810562134,
0.040006306022405624,
-0.02757442183792591,
-0... | 0.784423 | 0.766019 | 0.018405 |
What is a recursive algorithm in Python that can be used to generate permutations of a given set of elements? | glaive | [
0.006779985968023539,
0.03519592806696892,
-0.014577857218682766,
-0.03685275837779045,
0.026133235543966293,
-0.026386551558971405,
-0.007386723533272743,
0.05365768447518349,
0.010356700979173183,
-0.040237437933683395,
0.02505478821694851,
0.030645549297332764,
-0.03330947086215019,
0.0... | 0.797937 | 0.782582 | 0.015354 |
You are tasked with creating a program that can parse and analyze a given dataset in the form of a graph. The graph is represented by a set of triplets, each containing three elements: subject, predicate, and object. Your program should be able to take in this dataset and perform operations such as querying for specifi... | glaive | [
0.03407446667551994,
0.01386815682053566,
-0.0348036102950573,
-0.03216489776968956,
0.028949111700057983,
-0.03538477048277855,
-0.016458293423056602,
0.05960315093398094,
0.03723045438528061,
-0.012185986153781414,
0.029324855655431747,
0.029651252552866936,
-0.0038117929361760616,
-0.00... | 0.819863 | 0.800059 | 0.019804 |
You are tasked with solving a problem related to processing guard log data for a specific date in Clojure. The input will be a list of strings representing events that occurred during a specific date. Each event has a timestamp and one of the following types: "begins", "asleep", or "wakes". The goal is to process this ... | glaive | [
0.037264611572027206,
0.03001195751130581,
-0.04546379670500755,
-0.03829779848456383,
0.02200951986014843,
-0.043071646243333817,
-0.01869846321642399,
0.053575411438941956,
0.06147931143641472,
0.0001904258388094604,
0.03175355866551399,
0.019601019099354744,
-0.0249751266092062,
-0.0142... | 0.814015 | 0.799294 | 0.014721 |
I have an array with elements [4, 3, 6, 2, 1]. How can I write a code to sort these elements in ascending order? | glaive | [
0.03246544674038887,
0.024808092042803764,
-0.013534829951822758,
-0.02378428541123867,
0.036615464836359024,
-0.04813564568758011,
-0.022320445626974106,
0.052541643381118774,
0.02721996419131756,
-0.026915214955806732,
0.029790205880999565,
0.009681043215095997,
-0.053113166242837906,
-0... | 0.802867 | 0.785051 | 0.017816 |
You are tasked with implementing a function to calculate the sum of a finite geometric series. The function should take two parameters: the base value `x` and the number of terms `n`. The sum of the series is given by the formula $\sum_{i=0}^{n-1} x^i$.
Write a function `calculateGeometricSeries(x: number, n: number):... | glaive | [
0.002959958976134658,
0.04390134662389755,
-0.03913848102092743,
-0.04962347820401192,
0.04275212436914444,
-0.025245483964681625,
-0.016274360939860344,
0.04803960397839546,
0.044447820633649826,
-0.009807855822145939,
0.02578170970082283,
0.02956957370042801,
-0.04500649869441986,
-0.002... | 0.80642 | 0.766912 | 0.039508 |
You are tasked with implementing a program in C that utilizes the CUDA and cuBLAS libraries to perform matrix manipulation. Your program should allocate memory on the device, transfer data to and from the device, and apply a modification to the matrix using the cuBLAS library.
You are required to perform the following... | glaive | [
0.028409143909811974,
0.042994819581508636,
-0.02606302499771118,
-0.024050066247582436,
0.039435070008039474,
-0.03521418571472168,
-0.0335984006524086,
0.09346303343772888,
0.05034060776233673,
-0.030688494443893433,
0.00572405569255352,
0.03884818032383919,
-0.00818159244954586,
-0.0148... | 0.799011 | 0.778226 | 0.020786 |
You are tasked with creating a Clojure namespace called `math-operations` that includes functions for basic mathematical operations. The namespace should include the following functions:
- `addition`: Takes in two numbers and returns their sum.
- `subtraction`: Takes in two numbers and returns the result of subtracting... | glaive | [
0.04007570818066597,
0.03205502778291702,
-0.036518242210149765,
-0.039538998156785965,
0.0483272559940815,
-0.013415143825113773,
-0.017352910712361336,
0.03683614730834961,
0.05274315923452377,
-0.007743166293948889,
0.020966267213225365,
0.023560678586363792,
-0.01694635860621929,
-0.02... | 0.793333 | 0.773106 | 0.020227 |
You are tasked with creating a program that calculates the probability distribution of a quantum system and then visualizes it using a 3D plot and contour plot. The system consists of 16 qubits and has 4 possible states. The system is described by the `amplitude` and `amplitude2` functions, which depend on the variable... | glaive | [
0.0005561560392379761,
0.02998689003288746,
-0.0321338064968586,
-0.020025037229061127,
0.04566068574786186,
-0.026957325637340546,
-0.027240242809057236,
0.07023989409208298,
0.041788868606090546,
0.005585073493421078,
0.030071338638663292,
0.03843601420521736,
-0.010585914365947247,
-0.0... | 0.80372 | 0.773604 | 0.030116 |
You are tasked with implementing a program to estimate PM2.5 source apportionment and related health effects using Hamiltonian Monte Carlo (HMC) estimation. The program should take in the following data:
- T: the number of time points
- I: the number of pollutants
- K: the number of sources
- X: a matrix of size T x I ... | glaive | [
0.0059248604811728,
0.009717733599245548,
-0.03211096674203873,
-0.03936551883816719,
0.03822976350784302,
-0.04164126142859459,
-0.03763076290488243,
0.0699155181646347,
0.04528205841779709,
-0.018788538873195648,
0.01889444701373577,
0.03506957367062569,
-0.013915503397583961,
-0.0074602... | 0.80461 | 0.785231 | 0.019379 |
What is an algorithm and function that can be used to calculate the sum of all digits of a number? | glaive | [
0.026244744658470154,
0.024852443486452103,
-0.03219635412096977,
-0.04791403189301491,
0.044263873249292374,
-0.023518264293670654,
-0.03200415149331093,
0.03371312841773033,
0.020874209702014923,
-0.02849735878407955,
0.012887323275208473,
0.04618535563349724,
-0.048282086849212646,
-0.0... | 0.794704 | 0.766008 | 0.028696 |
You are tasked with implementing a function to perform inverse quad mapping. The function takes in a set of global coordinates and a set of points, and returns the local coordinates corresponding to the given global coordinates. The global coordinates and points are represented as arrays of 2D vectors.
You need to wri... | glaive | [
0.01954418048262596,
0.05156974494457245,
0.0006948778172954917,
-0.04280287027359009,
0.05236634239554405,
-0.010121664963662624,
-0.008091947063803673,
0.0652124285697937,
0.032676756381988525,
-0.000016874695575097576,
0.005777562968432903,
0.029495013877749443,
-0.012283574789762497,
-... | 0.791757 | 0.773347 | 0.01841 |
You are tasked with implementing a GPU-accelerated function to convert dense data to an octree data structure. The function should support different reduction methods such as sum, average, and maximum. The input dense data is in either DHWC or CDHW format and needs to be converted to an octree data structure. The octre... | glaive | [
-0.00647346256300807,
0.045692142099142075,
-0.04117751121520996,
-0.03825309872627258,
0.02210822142660618,
-0.03826664388179779,
-0.024530934169888496,
0.08597738295793533,
0.047135766595602036,
-0.002586048562079668,
0.02007743902504444,
0.019141681492328644,
-0.012197494506835938,
0.01... | 0.803533 | 0.785608 | 0.017926 |
Can you provide a solution to grouping a list of words into categories based on their length? | glaive | [
0.020130867138504982,
0.0003650764701887965,
-0.02500372938811779,
-0.03108425810933113,
0.031029293313622475,
-0.04980514943599701,
-0.04614723101258278,
0.031230038031935692,
0.040902648121118546,
-0.035667844116687775,
0.009286134503781796,
0.033452633768320084,
-0.03690209612250328,
-0... | 0.7917 | 0.771287 | 0.020413 |
You are required to implement a set of atomic operations in CUDA for various data types. These operations include add, max, and min. The atomic functions are used to ensure that the operation is performed without interference from other threads. The atomic functions are provided in the xlib::atomic namespace.
Your tas... | glaive | [
0.027561454102396965,
0.03879927843809128,
-0.018559623509645462,
-0.0059517123736441135,
0.038094662129879,
-0.03395690396428108,
-0.009494014084339142,
0.1165701225399971,
0.056742262095212936,
-0.009360450319945812,
0.03558908775448799,
0.025787847116589546,
0.001375356107018888,
0.0010... | 0.792165 | 0.777868 | 0.014297 |
You are tasked with creating a program that counts the occurrences of each unique number in a given list and outputs the frequency of each number. For example, given the input list [0, 1, 0, 2, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1], the program should output:
0: 3
1: 8
2: 1 | glaive | [
0.013031477108597755,
0.024531327188014984,
-0.03497188910841942,
-0.03230597451329231,
0.04244981333613396,
-0.010660678148269653,
-0.021611234173178673,
0.05812668800354004,
0.022898491472005844,
-0.009960856288671494,
0.0037357385735958815,
0.022581296041607857,
-0.022057805210351944,
-... | 0.822694 | 0.764357 | 0.058337 |
You are tasked with implementing a program that generates a sequence of numbers following the pattern described by the formula A080584: A run of 3*2^n 0's followed by a run of 3*2^n 1's, for n=0, 1, 2, ...
Your program should take an input n and output the sequence of 0's and 1's according to the given pattern.
For e... | glaive | [
0.03189823031425476,
0.034967053681612015,
-0.011751355603337288,
-0.0300744716078043,
0.03013736568391323,
-0.02287287637591362,
-0.03822927922010422,
0.08049757033586502,
0.028960460796952248,
-0.017978966236114502,
0.02681739255785942,
0.030576324090361595,
-0.03330628201365471,
-0.0214... | 0.82448 | 0.773955 | 0.050526 |
You are tasked with implementing a system of differential equations in a programming language that supports differential algebra. The system is defined by the following set of differential equations:
diff(KS00(t), t) - (FS11(t)*gamma1100 + gamma1000*FS10(t) + FS01(t)*gamma0100 + b00*KS00(t) - S00(t)*K(t)*a00),
diff(KS... | glaive | [
0.026172716170549393,
0.02015708200633526,
-0.02730790339410305,
-0.0574798621237278,
0.043005023151636124,
-0.04947211220860481,
-0.026816751807928085,
0.07855506986379623,
0.04132021963596344,
-0.015016356483101845,
0.022685937583446503,
0.055413950234651566,
-0.03671274706721306,
-0.003... | 0.826027 | 0.800699 | 0.025328 |
You are tasked with implementing a CUDA kernel function in C++ that takes in a number of elements, two arrays of double values (left and right), and an output array. The function also takes in the number of elements per batch, a threshold value, and a mode value. The goal is to efficiently process the input arrays and ... | glaive | [
0.003998256288468838,
0.05392864719033241,
-0.01228902954608202,
-0.013862133026123047,
0.026126056909561157,
-0.0008983972948044538,
-0.03448038175702095,
0.11242906004190445,
0.04037671163678169,
-0.010056046769022942,
0.03117634914815426,
0.04914115369319916,
0.00002987894185935147,
0.0... | 0.7955 | 0.771155 | 0.024345 |
You are tasked with implementing a helper class for adding and subtracting cluster elements on the device. The class should provide functions to initialize real reciprocal clusters if momentum is true, add cluster elements, subtract cluster elements, and find the negative of a cluster element. The implementation should... | glaive | [
0.024260787293314934,
0.0365566611289978,
-0.019498907029628754,
-0.04246726632118225,
0.034340448677539825,
-0.025333289057016373,
-0.016258422285318375,
0.0909072682261467,
0.057650886476039886,
0.0046983035281300545,
-0.0014467586297541857,
0.03264174237847328,
-0.02533889375627041,
-0.... | 0.813368 | 0.796064 | 0.017304 |
You are tasked with creating a program that calculates the expansion of a given generating function. The generating function is in the form (1+x)/(1-8*x). Your program should take an input integer n and return the expansion of the generating function up to the nth term. | glaive | [
0.030214503407478333,
0.03351471200585365,
-0.04136044159531593,
-0.03544707968831062,
0.02064458839595318,
-0.039233919233083725,
-0.033234428614377975,
0.07943084836006165,
0.04624031484127045,
-0.011629465967416763,
0.024848943576216698,
0.02031560055911541,
-0.060790833085775375,
-0.02... | 0.816754 | 0.782485 | 0.034269 |
Can you provide a function that prints all the possible permutations of an array of numbers with the condition that the order matters? | glaive | [
0.020474964752793312,
0.037483155727386475,
-0.021724916994571686,
-0.02276848442852497,
0.028238017112016678,
-0.03747113049030304,
-0.019354594871401787,
0.02706245519220829,
0.023626746609807014,
-0.034505702555179596,
0.0201583094894886,
0.035490669310092926,
-0.03233982250094414,
-0.0... | 0.811429 | 0.79352 | 0.01791 |
Write a OCaml function called "isPowerOfTwo" that takes an integer n as input and returns true if n is a power of 2, and false otherwise. A power of 2 is a number of the form 2^k where k is an integer. | glaive | [
0.022833654657006264,
0.03242114558815956,
-0.016407126560807228,
-0.0441553108394146,
0.02758169360458851,
-0.0449698269367218,
0.0010866810334846377,
0.05864115059375763,
0.055353615432977676,
-0.03878112882375717,
0.02889852784574032,
0.04196338355541229,
-0.007372780237346888,
-0.02504... | 0.816101 | 0.801206 | 0.014895 |
You are tasked with implementing a matrix multiplication kernel in CUDA for a given matrix of size N x N. The kernel function is expected to take two input matrices, perform matrix multiplication, and store the result in a third output matrix. The input matrices and the output matrix are represented by the custom Matri... | glaive | [
0.02059388905763626,
0.05597895383834839,
-0.01843438856303692,
-0.023631997406482697,
0.04257629066705704,
-0.004257380496710539,
-0.035543717443943024,
0.09737585484981537,
0.03999810665845871,
-0.0220202524214983,
0.022433752194046974,
0.03187015652656555,
-0.013078880496323109,
0.00708... | 0.792126 | 0.771858 | 0.020267 |
You are working with a programming language that supports enumeration types and sets, and you need to implement a function that performs various operations on these data structures. Specifically, you need to write code to define an enumeration type for hobbits and wizards, create sets for these types, and perform opera... | glaive | [
0.03851328045129776,
0.0259539932012558,
-0.014562834985554218,
-0.029550034552812576,
0.03703121840953827,
-0.04973984882235527,
-0.013599756173789501,
0.059366486966609955,
0.041504815220832825,
-0.03561129793524742,
0.0470493845641613,
0.043655991554260254,
-0.027272207662463188,
-0.008... | 0.821413 | 0.803715 | 0.017698 |
What is a way to rotate the elements of an array by a specific number of positions in a programming language? | glaive | [
0.015301236882805824,
0.025704989209771156,
-0.017226144671440125,
-0.025585196912288666,
0.022716153413057327,
-0.03175417706370354,
-0.018253562971949577,
0.03351089730858803,
0.024616293609142303,
-0.047796785831451416,
0.016187217086553574,
0.038120292127132416,
-0.0466657355427742,
-0... | 0.793633 | 0.778929 | 0.014705 |
You are tasked with implementing a Bayesian network using the FullBNT-1.0.4 library in MATLAB. The network structure is defined with 4 nodes (C, S, R, W) and the following connections: C -> R, C -> S, R -> W, S -> W. The node sizes are all 2, indicating a binary domain. You need to create conditional probability tables... | glaive | [
0.019505511969327927,
0.006742528174072504,
-0.04907016083598137,
-0.006799624767154455,
0.05122644826769829,
-0.04566077142953873,
-0.006832033395767212,
0.06100364774465561,
0.051880206912755966,
-0.005157943814992905,
0.005328737664967775,
0.03908396139740944,
-0.010106147266924381,
0.0... | 0.792021 | 0.774816 | 0.017204 |
You are tasked with writing a program that takes a vector of unsigned 8-bit integers and groups them into chunks of three. However, you are only interested in the middle value of each chunk. Your program should then print out the middle value of each chunk. | glaive | [
0.030389273539185524,
0.016166653484106064,
-0.03616281598806381,
-0.03066316619515419,
0.0284565519541502,
-0.005357825197279453,
-0.03544427827000618,
0.0665765181183815,
0.025612015277147293,
-0.0355459600687027,
0.03120962344110012,
0.029257038608193398,
-0.033824000507593155,
-0.04876... | 0.824904 | 0.800333 | 0.024571 |
You are tasked with implementing a function in Clojure that calculates the total cost of a list of items. Each item is represented as a map with keys :name and :price. The function should take a list of such maps and return the total cost of all the items combined.
For example, given the input:
[{:name "apple" :price ... | glaive | [
0.014507000334560871,
0.050756700336933136,
-0.037126049399375916,
-0.03445509448647499,
0.04825204610824585,
-0.02903417870402336,
-0.014258629642426968,
0.03671238198876381,
0.04336702078580856,
-0.012753784656524658,
0.035459116101264954,
0.036588091403245926,
-0.028220130130648613,
-0.... | 0.793889 | 0.775948 | 0.01794 |
You are tasked with writing a shader program in GLSL that takes in vertex and color attributes, applies some mathematical transformations, and outputs a modified color and position for each vertex. The shader program should use the provided gtf_Color, gtf_Vertex, and gtf_ModelViewProjectionMatrix variables, and impleme... | glaive | [
0.015654856339097023,
0.03403397649526596,
-0.010952956974506378,
-0.061468709260225296,
0.029203137382864952,
-0.050773873925209045,
-0.03609464690089226,
0.06636177748441696,
0.04322563484311104,
-0.026380009949207306,
0.038006700575351715,
0.024135705083608627,
-0.017346441745758057,
-0... | 0.788415 | 0.773596 | 0.014819 |
You are tasked with creating a branch ALU module in Verilog, which takes two 32-bit input values (val1 and val2), a 5-bit ALU operation code (aluop), and outputs a single bit (branchout) based on the specified ALU operation. The ALU operation codes are as follows:
- `ALU_EQ: 1 if val1 is equal to val2, 0 otherwise
- `A... | glaive | [
0.02002268098294735,
0.025691021233797073,
-0.01496556680649519,
-0.0271419957280159,
0.017072239890694618,
-0.010886689648032188,
-0.01397684309631586,
0.08562254905700684,
0.036672674119472504,
-0.017401572316884995,
0.03675158694386482,
0.03797873854637146,
-0.0027104539331048727,
0.008... | 0.799047 | 0.781347 | 0.0177 |
You are tasked with writing a small program in C that takes input and outputs it in different formats. You need to create functions for inputting an integer, outputting an integer, inputting a boolean, outputting a boolean, inputting a character, outputting a character, and outputting a newline. The main function shoul... | glaive | [
0.02067040279507637,
0.04234946891665459,
-0.023887500166893005,
-0.017366288229823112,
0.03144604712724686,
-0.04317096620798111,
-0.02717922069132328,
0.07112815231084824,
0.041591253131628036,
-0.01743078976869583,
0.027164215222001076,
0.0508035309612751,
-0.023295940831303596,
-0.0416... | 0.804925 | 0.78726 | 0.017665 |
You are tasked with implementing a Java class that calculates the average of a set of numbers. The class should have the following requirements:
1. The class should be named "AverageCalculator" and be within the package "com.average.calculator".
2. The class should have a method named "calculateAverage" that takes in a... | glaive | [
0.013817166909575462,
0.02368522249162197,
-0.03301255777478218,
-0.03955065459012985,
0.050406988710165024,
-0.039808034896850586,
-0.031288351863622665,
0.037733860313892365,
0.021257901564240456,
-0.043475545942783356,
0.02502494491636753,
0.007241650018841028,
-0.03292452543973923,
-0.... | 0.786412 | 0.766375 | 0.020037 |
You are tasked with creating a program that calculates and visualizes the probability amplitudes of a quantum system. The program should take the number of qubits (nqubits), the system name (name), the number of states (nstates), and the amplitude and probability functions as inputs. The program should then use the NMa... | glaive | [
0.010292839258909225,
0.023114293813705444,
-0.03187498822808266,
-0.025385646149516106,
0.039294566959142685,
-0.04307238757610321,
-0.0225602388381958,
0.06550690531730652,
0.03599100187420845,
0.0028616006020456553,
0.021497610956430435,
0.042597394436597824,
-0.02629179134964943,
-0.02... | 0.797554 | 0.774164 | 0.02339 |
You are given three lists of characters, first, sec, and third. You need to write a program that checks if the concatenation of the first two lists, when sorted, is equal to the third list when sorted. If they are equal, the program should output "YES", otherwise, it should output "NO". | glaive | [
0.02624504081904888,
0.0005126558244228363,
-0.02409880980849266,
-0.0373990423977375,
0.033813901245594025,
-0.026521209627389908,
0.016002703458070755,
0.051870979368686676,
0.037627238780260086,
-0.01607089675962925,
0.025146039202809334,
0.02626989409327507,
-0.02615281380712986,
-0.04... | 0.819217 | 0.789047 | 0.03017 |
Can you provide a binary search algorithm to locate a specific element in an integer array? | glaive | [
0.02002750337123871,
0.032136280089616776,
-0.03367431461811066,
-0.02062784507870674,
0.019632652401924133,
-0.05477026849985123,
-0.030254893004894257,
0.035147976130247116,
0.04469295218586922,
-0.038765665143728256,
0.029294081032276154,
0.01691402867436409,
-0.027687251567840576,
-0.0... | 0.805569 | 0.785004 | 0.020565 |
You are tasked with creating a program to calculate the probability of a quantum state. The program should take in the values of x and y and use the given amplitude function to calculate the probability using the formula |amplitude[x, y]|^2. Once the probability is calculated, the program should then find the maximum p... | glaive | [
0.0006977331358939409,
0.03153112903237343,
-0.034220416098833084,
-0.02148478291928768,
0.044831063598394394,
-0.02175537310540676,
-0.015811318531632423,
0.07695170491933823,
0.04447610676288605,
-0.000753600790631026,
0.029314374551177025,
0.03900652006268501,
-0.019870402291417122,
-0.... | 0.7914 | 0.763499 | 0.027901 |
You are tasked with creating a program to calculate the probability amplitudes for a quantum system. The amplitudes are given by the function `amplitude`, which takes two input variables `x` and `y`. The probability of each amplitude is then calculated using the function `probability`, which takes the same input variab... | glaive | [
0.00446636276319623,
0.03752083331346512,
-0.027518445625901222,
-0.014735248871147633,
0.047781139612197876,
-0.036768827587366104,
-0.023663323372602463,
0.06417796015739441,
0.030700113624334335,
0.002313097706064582,
0.02533102221786976,
0.03329494595527649,
-0.02381163276731968,
-0.01... | 0.806832 | 0.77493 | 0.031903 |
You are tasked with writing a SQL query to retrieve the values of column 'a' from table 't1' where the rowid from 't1' is greater than the value of column 'r' in table 't2', and where the value of column 'a' in table 't2' is equal to 14. The results should be ordered by the rowid from 't1'. | glaive | [
0.04081244766712189,
0.04568645358085632,
-0.008134584873914719,
-0.029753070324659348,
0.03561336174607277,
-0.016083450987935066,
-0.02901235781610012,
0.0621984526515007,
0.04409800469875336,
-0.005653148051351309,
0.02652677707374096,
0.024898376315832138,
-0.03325929865241051,
0.00461... | 0.80414 | 0.770397 | 0.033743 |
You are tasked with creating a function in Mathematica that calculates the mean of a given dataset, but ignores any zero values in the dataset.
Write a function named "MeanNoZero" that takes in a list of numerical data as input and returns the mean of the non-zero values in the dataset.
For example:
MeanNoZero[{1, 2,... | glaive | [
0.011662700213491917,
0.01643957942724228,
-0.052240077406167984,
-0.058865588158369064,
0.044579558074474335,
0.005899329204112291,
-0.017383171245455742,
0.05065111443400383,
0.04039618372917175,
-0.01072784699499607,
0.01335145439952612,
0.014057166874408722,
-0.021628648042678833,
-0.0... | 0.780811 | 0.765476 | 0.015336 |
You are tasked with implementing a function that performs matrix multiplication using the cuBLAS library in C++ for GPU computation. Your function should take in two input matrices in column-major format, perform the matrix multiplication, and store the result in a third matrix also in column-major format.
The functio... | glaive | [
0.028769947588443756,
0.04077640548348427,
-0.04704614728689194,
-0.030020635575056076,
0.048594407737255096,
-0.012467633001506329,
-0.02686040662229061,
0.10700590908527374,
0.0347011461853981,
-0.01683282107114792,
0.008654669858515263,
0.03594215214252472,
-0.010754276067018509,
-0.005... | 0.799251 | 0.77663 | 0.022621 |
You are tasked with creating a C++ function that constructs a submodular function based on the specified precision and device. The function should take in a matrix V, representing the ground set, a precision (either "fp16", "fp32", or "fp64"), a device (either "gpu" or "cpu"), and an integer workerCount. Depending on t... | glaive | [
0.02038723975419998,
0.040070973336696625,
-0.03771563246846199,
-0.02332353964447975,
0.05857476219534874,
-0.011511281132698059,
-0.041573166847229004,
0.08519647270441055,
0.04143625125288963,
-0.005469493102282286,
0.02419886738061905,
0.04551627114415169,
0.0013545939000323415,
-0.000... | 0.800452 | 0.781537 | 0.018915 |
You are tasked with creating a horizontal tree layout algorithm for a visualization library. The algorithm should compute the children for a given node, excluding any nodes that have already been laid out. You need to implement the `computeChildrenFor` method in the `RSHorizontalTreeLayout` class. The method should tak... | glaive | [
-0.0007374613778665662,
0.025180814787745476,
-0.03754359856247902,
-0.025330685079097748,
0.038337163627147675,
-0.04041526839137077,
0.0016376387793570757,
0.06807394325733185,
0.037446729838848114,
-0.016455037519335747,
0.03683372214436531,
0.021029286086559296,
-0.021376611664891243,
... | 0.813015 | 0.792114 | 0.020901 |
I am working on defining a Grothendieck topology for a given presheaf in a category using the finest (largest) topology for which the presheaf is a sheaf. I need to create a function that constructs the finest topology for a single presheaf and another function that constructs the finest topology for a set of presheave... | glaive | [
0.035371728241443634,
0.027503693476319313,
-0.025070715695619583,
-0.03300359472632408,
0.02635783888399601,
-0.014353112317621708,
-0.033925026655197144,
0.058812402188777924,
0.039728064090013504,
0.007952682673931122,
0.002161420648917556,
0.0367942750453949,
-0.016149131581187248,
-0.... | 0.801651 | 0.782603 | 0.019048 |
You are tasked with implementing a set of injective maps for a given dimension k. The set of injective maps is defined as single_cubes(k) and it operates on the domain [0,1]^k and the codomain [0,1]^k. The set of injective maps provides the following operations:
- `is_element/single_cubes`: Checks if a given input is i... | glaive | [
0.042401015758514404,
0.05981198698282242,
-0.011543674394488335,
-0.008295904844999313,
0.04440908879041672,
-0.03104642778635025,
0.0018517599673941731,
0.05831677466630936,
0.035469900816679,
-0.0024460861459374428,
0.025545058771967888,
0.019425664097070694,
0.019463103264570236,
-0.00... | 0.813594 | 0.782602 | 0.030992 |
You are tasked with implementing a simple vertex shader using vec3 to calculate colors. The task involves declaring and initializing an array of vec3, assigning values to its elements, and using these values to calculate the color to be passed on to the fragment shader. Additionally, you will need to apply a transforma... | glaive | [
0.02907816506922245,
0.034240055829286575,
-0.00826290249824524,
-0.038996946066617966,
0.0349467508494854,
-0.05217348784208298,
-0.02024829387664795,
0.07725338637828827,
0.030992893502116203,
-0.0255229864269495,
0.045440636575222015,
0.02210354432463646,
-0.00030695044551976025,
-0.002... | 0.784803 | 0.769229 | 0.015574 |
You are tasked with implementing a function that takes in a list of integers and returns the Fibonacci sequence up to the given number of terms. The function should use the given code snippet as a framework for defining the required operations. | glaive | [
0.029025016352534294,
0.025595583021640778,
-0.02572603151202202,
-0.026003271341323853,
0.05235370993614197,
-0.02905280701816082,
-0.0365590862929821,
0.06478013843297958,
0.021512042731046677,
0.001581442542374134,
0.02313903719186783,
0.049800124019384384,
-0.026071244850754738,
-0.009... | 0.818876 | 0.781905 | 0.036971 |
You are asked to create a program that checks all possible legal indexing for assignment statements (left side) and indexed expressions (right side) in a given code snippet. The program should be able to handle various data types such as real, int, vector, row_vector, matrix, and their combinations. The program should ... | glaive | [
0.019952278584241867,
0.02507542446255684,
-0.012135036289691925,
-0.018302785232663155,
0.023423349484801292,
-0.01336010079830885,
-0.00835348665714264,
0.06779420375823975,
0.026825547218322754,
-0.023214777931571007,
0.03035903349518776,
0.02180331014096737,
-0.021241458132863045,
-0.0... | 0.808242 | 0.788038 | 0.020204 |
You are tasked with implementing a function bfi2 that takes an integer parameter and performs a series of operations on it. The function should take the following steps:
1. Perform the bfi2 operation on the input parameter.
2. Perform a series of g operations on the result of the previous step, each with specific param... | glaive | [
0.0383915975689888,
0.03581874817609787,
-0.02540041133761406,
-0.035451099276542664,
0.03843953460454941,
-0.027347447350621223,
-0.019984686747193336,
0.05070914700627327,
0.044472381472587585,
0.01424754410982132,
0.020048556849360466,
0.030021745711565018,
-0.01231249701231718,
0.01077... | 0.803534 | 0.780428 | 0.023106 |
You are tasked with implementing a function in OCaml that takes a list of integers and returns the sum of all the numbers in the list. You should define a module called "Sum" and a function called "sum_all" within that module. The function should take a list of integers and return the sum of all the numbers in the list... | glaive | [
0.0018362068803980947,
0.028052957728505135,
-0.03238322585821152,
-0.0671209767460823,
0.05590255931019783,
-0.03080095909535885,
-0.017573412507772446,
0.03546321764588356,
0.04588916897773743,
-0.00799829326570034,
0.0163425263017416,
0.060535259544849396,
-0.02236105687916279,
-0.00953... | 0.800092 | 0.783298 | 0.016794 |
You are tasked with creating a function that generates a password based on the input number. The function should return a string that meets the following criteria:
- When called with a number, it should return a string.
- When called with 0, it should return an empty password.
- When called with 1, it should return a o... | glaive | [
0.035058170557022095,
0.03070089966058731,
-0.011145004071295261,
-0.04284451901912689,
0.04117746651172638,
-0.03998389095067978,
-0.006569061428308487,
0.04939776659011841,
0.016335252672433853,
-0.002902860986068845,
0.02553592436015606,
0.034542880952358246,
-0.035888466984033585,
-0.0... | 0.797927 | 0.777894 | 0.020033 |
You are tasked with creating a CUDA program to compute the Mandelbrot set using the given mathematical terminology for Mandelbrot set definition. The program should iteratively apply the function f(z) = z*z * c, where z and c are complex numbers. The program should take in the maximum number of iterations and a complex... | glaive | [
0.007789198309183121,
0.06254258751869202,
-0.002332603093236685,
-0.02749546989798546,
0.029574092477560043,
-0.01593710109591484,
-0.023778056725859642,
0.09698978066444397,
0.06158500537276268,
-0.02168245241045952,
0.012978937476873398,
0.04311211779713631,
-0.014058270491659641,
-0.00... | 0.805427 | 0.772875 | 0.032552 |
You are tasked with creating a program that takes in a 3x3 matrix and a 1-dimensional array of length 4 as input. The program should then perform element-wise multiplication between the array and the matrix, storing the result in a new 3x3 matrix. Additionally, the program should ensure that the multiplication is perfo... | glaive | [
0.03600616753101349,
0.04612680897116661,
-0.02576104924082756,
-0.032693035900592804,
0.06289424747228622,
-0.02515457198023796,
-0.024640711024403572,
0.07262958586215973,
0.02766556106507778,
-0.018197305500507355,
0.01006332878023386,
0.03409205377101898,
-0.04540017619729042,
-0.03467... | 0.807663 | 0.781005 | 0.026658 |
You are tasked with implementing a dining philosopher's problem simulator. The dining philosopher's problem is a classic synchronization problem in computer science, in which a number of philosophers sit at a table with a bowl of spaghetti. Between each philosopher, there is a single fork. The philosophers can either b... | glaive | [
0.012965833768248558,
0.0021863423753529787,
-0.005951962433755398,
-0.015229877084493637,
0.010000286623835564,
-0.009320671670138836,
-0.010214929468929768,
0.07762499153614044,
0.04272614046931267,
-0.03708604723215103,
0.0433766134083271,
0.053260669112205505,
-0.020597049966454506,
-0... | 0.817886 | 0.803176 | 0.01471 |
You are tasked with implementing a function to find the best split in a decision tree for a machine learning model using the ThunderGBM library. The function takes as input the level of the tree and the device ID, and it uses various operations such as prefix sum calculation, RLE compression, and gain calculation to de... | glaive | [
0.012701542116701603,
0.024013841524720192,
-0.029210390523076057,
-0.04935824126005173,
0.0329742394387722,
-0.041043996810913086,
-0.02679487317800522,
0.0703250840306282,
0.049071479588747025,
-0.005023538134992123,
0.024732910096645355,
0.00404569786041975,
-0.012928169220685959,
0.033... | 0.809806 | 0.793513 | 0.016293 |
You are tasked with implementing a VariationalDenoising class in C++ using CUDA that will be used for image denoising. The class should have the ability to denoise an input image and produce a clean output image. The denoising process should be based on variational methods and should take into account parameters such a... | glaive | [
-0.011501076631247997,
0.033185433596372604,
-0.0009851017966866493,
-0.014566304162144661,
0.027892442420125008,
-0.007758061867207289,
-0.02388647384941578,
0.11497251689434052,
0.0370042659342289,
-0.028997890651226044,
0.03301986679434776,
0.019638661295175552,
0.005820359569042921,
0.... | 0.786087 | 0.768984 | 0.017103 |
You are tasked with creating a module in Verilog that computes the stochastic quotient y = a / b. The module should have the following parameters and inputs:
- Parameter: LFSR_WIDTH (default value 64)
- Inputs: CLK (clock signal), nRST (reset signal), a, b
- Output: y
The module should include the following internal w... | glaive | [
0.02106652781367302,
0.026311298832297325,
-0.04098488762974739,
-0.016975712031126022,
0.031041203066706657,
-0.021796194836497307,
-0.030863996595144272,
0.0821150466799736,
0.03332154080271721,
-0.02092895656824112,
0.03228232264518738,
0.05588504299521446,
-0.012732762843370438,
0.0017... | 0.800732 | 0.782151 | 0.018581 |
You are tasked with implementing a random graph construction routine in C++ that generates a random-regular(ish) graph. A random-regular(ish) graph is a graph where each node has a guaranteed degree of random neighbors, but loops, and multi-edges are possible, and in-degree is not guaranteed to be the same as out degre... | glaive | [
0.0026801403146237135,
0.02842848002910614,
-0.013563962653279305,
-0.031418852508068085,
0.02377973683178425,
-0.009945171885192394,
-0.04248020052909851,
0.07793334871530533,
0.02609875425696373,
-0.023974595591425896,
0.02483375556766987,
0.0373489186167717,
-0.003699887078255415,
0.014... | 0.803634 | 0.778987 | 0.024647 |
You are tasked with creating a C++ program that calculates the average of a set of numbers. The program should take input from the user for the number of elements in the set, and then prompt the user to enter each number. Once all the numbers are entered, the program should calculate the average and display it to the u... | glaive | [
0.01928645372390747,
0.021857930347323418,
-0.038766130805015564,
-0.02871754579246044,
0.05885189771652222,
-0.01900491490960121,
-0.030276156961917877,
0.09358818084001541,
0.036824289709329605,
-0.023063883185386658,
0.016858525574207306,
0.028278572484850883,
-0.029326332733035088,
-0.... | 0.784654 | 0.752022 | 0.032632 |
You are tasked with implementing a set of logical operations in ACL2, a programming language and theorem prover. Specifically, you need to define the following logical operations:
1. The logical OR (lior) and logical AND (land) operations, as well as their interactions with each other and with other logical operations... | glaive | [
0.01981969177722931,
0.020558103919029236,
-0.02608850598335266,
-0.03630966320633888,
0.014493603259325027,
-0.020209044218063354,
-0.029770417138934135,
0.06164684519171715,
0.04194409027695656,
-0.02150428295135498,
0.006615141406655312,
0.019962217658758163,
-0.02630113810300827,
-0.01... | 0.79027 | 0.775752 | 0.014519 |
You are tasked with creating a program to calculate the probability distribution and visualize it in a 3D plot and contour plot. The program should use the given amplitude, amplitude2, and probability functions to calculate the probability of a quantum state for given values of x and y. The maximum probability should b... | glaive | [
0.0014824626268818974,
0.028534092009067535,
-0.039814457297325134,
-0.03174735978245735,
0.043202970176935196,
-0.02405114285647869,
-0.02315048687160015,
0.07719018310308456,
0.04592296481132507,
0.00012857663386967033,
0.02810225449502468,
0.04189973324537277,
-0.02034006454050541,
-0.0... | 0.794803 | 0.770779 | 0.024024 |
You are tasked with creating a program to calculate the probability amplitudes and probabilities of a given quantum system. The system is defined by the number of qubits, the state name, the number of states, and the amplitudes and probabilities functions.
You need to write a program that takes the number of qubits, s... | glaive | [
0.009474006481468678,
0.03327422961592674,
-0.028406372293829918,
-0.016867678612470627,
0.03995569422841072,
-0.03501632437109947,
-0.02633441612124443,
0.06499670445919037,
0.023694628849625587,
-0.009754403494298458,
0.019706230610609055,
0.03722558915615082,
-0.02016211859881878,
-0.01... | 0.803629 | 0.768932 | 0.034697 |
You are tasked with creating a function in Python that takes a list of numbers as input and returns a new list with only the even numbers from the original list. You need to implement a function called filter_even_numbers that takes a list of integers as input and returns a new list containing only the even numbers in ... | glaive | [
0.030921248719096184,
0.020153241232037544,
-0.03821302950382233,
-0.03292055428028107,
0.03662657365202904,
-0.01979030855000019,
-0.01877708174288273,
0.04834023490548134,
0.024973664432764053,
-0.023138418793678284,
0.007409148383885622,
0.0420088954269886,
-0.019944291561841965,
-0.014... | 0.807219 | 0.786577 | 0.020642 |
You are tasked with creating a program that generates a sparse matrix representing the approximation of the Laplace operator on a regular grid using the finite difference method. The matrix will have a grid size that varies from 16 to 8192. The program should include the following methods to set the elements in the mat... | glaive | [
0.015140400268137455,
0.03973344340920448,
-0.018492018803954124,
-0.0552903451025486,
0.0516076423227787,
-0.026797860860824585,
-0.02396591566503048,
0.06098996847867966,
0.04843200743198395,
-0.020477240905165672,
0.04608340188860893,
0.05342764034867287,
-0.020938493311405182,
0.007743... | 0.807889 | 0.776553 | 0.031336 |
You are tasked with implementing a high-performance group-by aggregation function in C++ using the cudf library. The function should be able to perform various aggregation operations such as sum, min, max, average, and count on a set of input columns. The function should take the following inputs:
- ncols: the number o... | glaive | [
0.0034957758616656065,
0.015486939810216427,
-0.03368304297327995,
-0.02619117870926857,
0.0446639358997345,
-0.020463887602090836,
-0.02704470604658127,
0.09772804379463196,
0.040330447256565094,
0.002792696002870798,
0.0051019685342907906,
0.0050568352453410625,
-0.006239957641810179,
0.... | 0.804303 | 0.775455 | 0.028847 |
You have been tasked with creating a low-level routine in CHICKEN Scheme to implement a `make-pointer-vector` function. This function should take in a number `n` and an optional initialization value `init`, and return a pointer vector with `n` slots. Each slot should be initialized with the given `init` value. If `init... | glaive | [
0.023488536477088928,
0.02723127417266369,
-0.009246152825653553,
-0.01116861030459404,
0.03679990395903587,
-0.025540081784129143,
-0.00860503874719143,
0.07833200693130493,
0.033172961324453354,
-0.007417768705636263,
-0.0007858076714910567,
0.05109940096735954,
-0.0306997112929821,
0.00... | 0.81445 | 0.792284 | 0.022166 |
You are tasked with writing a function to prepare buffers for a specific operation. The function should take certain input addresses, perform a series of instructions, and then return the prepared buffers. The input addresses and the series of instructions are as follows:
Input Addresses:
- Address 1: addresses_WT_ht+... | glaive | [
0.03873946890234947,
0.04947081208229065,
-0.025749070569872856,
-0.011298038996756077,
0.03156783804297447,
-0.045777786523103714,
-0.020154284313321114,
0.06668182462453842,
0.06409308314323425,
-0.010495703667402267,
0.021215787157416344,
0.04806019365787506,
-0.039664123207330704,
-0.0... | 0.809265 | 0.792714 | 0.016551 |
You are tasked with implementing a wave equation in a programming language of your choice. The wave equation is given by:
∂^2u/∂x^2 = (cp)^2 * ∂^2u/∂t^2
where u is the pressure, x is the length, t is the time, and cp is the speed.
Write a program to solve the wave equation using the given formula and input the neces... | glaive | [
0.013362622819840908,
0.04031841456890106,
-0.04068218916654587,
-0.037197310477495193,
0.04659460857510567,
-0.0478941947221756,
-0.02629290148615837,
0.0931498110294342,
0.04151293635368347,
-0.016206705942749977,
0.03875518962740898,
0.03302031010389328,
-0.013053799979388714,
-0.026755... | 0.805155 | 0.790093 | 0.015062 |
You are tasked with writing a program that will read a file containing data about molecular structures and extract specific information from it. The file will contain rows of data in the following format:
- RESID: The ID of the residue
- NAME: The name of the atom
- NID: The ID of the atom
- X, Y, Z: The coordinates of... | glaive | [
0.0332995280623436,
0.019142167642712593,
-0.03713877871632576,
-0.04943449795246124,
0.026254719123244286,
-0.05773403123021126,
-0.02312205731868744,
0.051196303218603134,
0.05333017557859421,
-0.00967517402023077,
0.028212541714310646,
0.013928746804594994,
-0.03528395667672157,
0.01889... | 0.803721 | 0.784332 | 0.019389 |
You are given a task to create a benchmarking routine for a specific task related to block matrix-matrix multiplication on a GPU. The task involves measuring the performance of a specific operation (Y = A*X) on a GPU. The program should be able to read an input file containing the multiplication plan and other necessar... | glaive | [
0.05366958677768707,
0.044747646898031235,
-0.038120221346616745,
-0.026402024552226067,
0.014235397800803185,
-0.015592815354466438,
-0.041308850049972534,
0.07395784556865692,
0.047626376152038574,
-0.015042191371321678,
-0.00672099320217967,
0.01237504556775093,
-0.01628921553492546,
0.... | 0.797229 | 0.773074 | 0.024156 |
You are tasked with writing a program to calculate the number of sets of divisors of a given number n with an odd sum. The program should take an integer input n and return the count of such sets of divisors.
For example, if the input is 6, the program should return 1, as the divisors of 6 are {1, 2, 3, 6} and only th... | glaive | [
0.01359773613512516,
0.028249090537428856,
-0.04524580016732216,
-0.018945178017020226,
0.0311894528567791,
0.0005843500839546323,
-0.03375078737735748,
0.06935305893421173,
0.04470055550336838,
-0.003691837890073657,
0.010387885384261608,
0.0180717371404171,
-0.04164130240678787,
-0.02002... | 0.818789 | 0.770173 | 0.048615 |
How can I write a JavaScript algorithm that can find the largest numerical value within a multi-dimensional array of integers? The array can contain other arrays with integers. For example, consider the array [4,7,2,1, [0,6,5, [8,9,1],3], 7]. I need to be able to navigate through the nested arrays and identify the larg... | glaive | [
0.021275173872709274,
0.03361642360687256,
-0.029869912192225456,
-0.026359494775533676,
0.0388261154294014,
-0.024320553988218307,
-0.02426617406308651,
0.03414159268140793,
0.027216380462050438,
-0.03196710720658302,
0.033280063420534134,
0.031189098954200745,
-0.043886177241802216,
-0.0... | 0.810673 | 0.788684 | 0.021988 |
Can you provide an algorithm to calculate the sum of a given set of numbers? | glaive | [
0.02428009733557701,
0.014814132824540138,
-0.028606271371245384,
-0.030864762142300606,
0.04253864660859108,
-0.03011452592909336,
-0.020703783258795738,
0.03581893444061279,
0.037966955453157425,
-0.03553727641701698,
0.020264456048607826,
0.040468811988830566,
-0.05270858481526375,
-0.0... | 0.789317 | 0.75612 | 0.033197 |
You are tasked with creating a function that can extract a specific group of numbers from a given string based on a predefined regular expression pattern. The regular expression pattern is defined as follows:
- The string should start with "COD"
- It should be followed by exactly three digits
- It should end with "END"... | glaive | [
0.038709864020347595,
0.015246222727000713,
-0.043180517852306366,
-0.0604916550219059,
0.040028344839811325,
-0.02645058184862137,
-0.01913953199982643,
0.04510921984910965,
0.024062007665634155,
-0.01505961548537016,
0.018865300342440605,
0.030282922089099884,
-0.05006280913949013,
-0.01... | 0.806381 | 0.778439 | 0.027942 |
You are tasked with implementing complex number operations in a programming language. Complex numbers are represented as a pair of floating-point numbers, where the first number represents the real part and the second number represents the imaginary part.
Your task is to implement the following operations for complex ... | glaive | [
0.02834349125623703,
0.03519401699304581,
-0.02004781737923622,
-0.030306603759527206,
0.03804243728518486,
-0.014065838418900967,
0.006123207043856382,
0.06064974516630173,
0.04569259285926819,
-0.0066765667870640755,
0.03150027245283127,
0.026641856878995895,
-0.02349148690700531,
-0.007... | 0.806865 | 0.787851 | 0.019013 |
You are tasked with simulating a seating arrangement on a boat, following rules similar to Conway's Game of Life with some modifications. The boat's seating arrangement is represented as a matrix of characters, with floors denoted by periods (.) and seats denoted by other characters. The rules for the seating arrangeme... | glaive | [
0.021743202582001686,
0.018471872434020042,
-0.04400154948234558,
-0.021684523671865463,
0.026137104257941246,
-0.04009685665369034,
-0.013550285249948502,
0.05896727740764618,
0.03430815786123276,
-0.030124614015221596,
0.047987159341573715,
0.015905696898698807,
-0.033172789961099625,
-0... | 0.825438 | 0.784477 | 0.040961 |
How can I create a program that can identify an element in a two-dimensional array? | glaive | [
0.014276561327278614,
0.034285448491573334,
-0.03992543742060661,
-0.028194861486554146,
0.027881016954779625,
-0.036201778799295425,
-0.01655535027384758,
0.06775540113449097,
0.034323349595069885,
-0.03208465501666069,
0.018485091626644135,
0.03342121094465256,
-0.03423437848687172,
-0.0... | 0.791631 | 0.772976 | 0.018655 |
You are tasked with implementing a program that processes a list of coordinate pairs. Each pair represents the x and y coordinates of a point on a grid. The program should calculate the distance between each pair of points and output the distances in a specific format.
For example, given the following coordinate pairs... | glaive | [
0.009044789709150791,
0.03240690752863884,
-0.03299756348133087,
-0.05160157382488251,
0.03632032871246338,
-0.023459238931536674,
-0.03856306150555611,
0.033511288464069366,
0.0603317990899086,
-0.02678297832608223,
0.01805960200726986,
0.05376841500401497,
-0.04155852645635605,
0.0083880... | 0.809444 | 0.760668 | 0.048776 |
You are tasked with creating a function that takes in an array of numbers and returns the sum of all the numbers in the array. The function should be named "calculateSum" and should be implemented in JavaScript using the Node.js runtime environment. | glaive | [
0.008345081470906734,
0.030023915693163872,
-0.044192735105752945,
-0.047107428312301636,
0.06219493970274925,
-0.023520175367593765,
-0.02531915344297886,
0.03819558769464493,
0.034093260765075684,
-0.007519745267927647,
0.027527080848813057,
0.025109924376010895,
-0.03648319095373154,
-0... | 0.795495 | 0.768297 | 0.027198 |
How can I design a bubble sort algorithm to sort a list of integers? | glaive | [
0.007864666171371937,
0.010894698090851307,
-0.022827986627817154,
-0.030352378264069557,
0.030888713896274567,
-0.040647946298122406,
-0.03392591327428818,
0.04110034182667732,
0.018700500950217247,
-0.018037017434835434,
0.012014488689601421,
0.03885803371667862,
-0.03157423809170723,
-0... | 0.800897 | 0.782682 | 0.018216 |
I need to implement a single-linkage clustering algorithm in C++ using the `raft` library. The algorithm should be capable of constructing a KNN graph to scale the algorithm beyond the n^2 memory consumption of implementations that use the fully-connected graph of pairwise distances. The algorithm should connect a knn ... | glaive | [
0.012389220297336578,
0.036679256707429886,
-0.03374620899558067,
-0.02490505948662758,
0.018786482512950897,
-0.011571510694921017,
-0.018360383808612823,
0.08079884201288223,
0.03344711288809776,
-0.012814071960747242,
0.018867919221520424,
0.022825021296739578,
-0.008896410465240479,
0.... | 0.802066 | 0.786238 | 0.015829 |
You are tasked with implementing a binomial mixture model with covariates in a programming language that supports probabilistic programming. The model involves a number of transects, sites, and temporal replications, as well as various covariates such as elevation, litter, stream, RH, temperature, and ground cover. The... | glaive | [
-0.027253398671746254,
0.008702067658305168,
-0.03056446462869644,
-0.02991103008389473,
0.031598035246133804,
-0.018736766651272774,
-0.024082237854599953,
0.07094595581293106,
0.04774516820907593,
-0.0042907302267849445,
0.0154502484947443,
0.06027453392744064,
0.008262451738119125,
0.01... | 0.804109 | 0.789561 | 0.014547 |
You are tasked with implementing a data structure to represent an Abstract Syntax Tree (AST) for a programming language. The AST should support different types of nodes, including atoms, booleans, integers, lists, and dotted lists. An atom is a string, a boolean is either true or false, an integer is a 64-bit signed in... | glaive | [
0.03172118589282036,
0.01816871576011181,
-0.033316221088171005,
-0.02655126340687275,
0.03420153260231018,
-0.046663641929626465,
0.005198400933295488,
0.07866399735212326,
0.04409937560558319,
-0.030970370396971703,
0.031580619513988495,
0.031135790050029755,
-0.01927441917359829,
0.0014... | 0.80607 | 0.784983 | 0.021087 |
Can you provide Python code that can find the pair of numbers from an array whose sum is closest to a given number? | glaive | [
0.007702669128775597,
0.03217218443751335,
-0.038920264691114426,
-0.030661622062325478,
0.0400109626352787,
-0.02928578108549118,
-0.01750517636537552,
0.025592979043722153,
0.03148498013615608,
-0.027808306738734245,
0.023771828040480614,
0.03330153599381447,
-0.0329887755215168,
0.00189... | 0.811535 | 0.785428 | 0.026107 |
You are tasked with creating a Rust program that reads a binary file "str_encodings.bin" and processes its content according to a specific data structure. The program should be able to read the file and extract two values: a vector of 14 unsigned integers and a string.
The vector of integers should contain the followi... | glaive | [
0.01270286925137043,
0.025286227464675903,
-0.004404906183481216,
-0.05689241364598274,
0.03190585970878601,
-0.035826459527015686,
-0.002097802935168147,
0.07656808942556381,
0.03915666416287422,
-0.008674840442836285,
0.02274775691330433,
0.01781393773853779,
-0.01945328712463379,
0.0046... | 0.804839 | 0.78838 | 0.016459 |
You are tasked with creating a simple service called "Calculator" that provides the following operations:
- Addition: takes two integers as input and returns their sum
- Subtraction: takes two integers as input and returns the result of the first integer minus the second integer
- Multiplication: takes two integers as ... | glaive | [
0.030940616503357887,
0.03960059583187103,
-0.022406263276934624,
-0.03782474994659424,
0.05991669371724129,
-0.03047853522002697,
-0.015245693735778332,
0.07232293486595154,
0.061292730271816254,
-0.016089491546154022,
0.02772832103073597,
0.03530439734458923,
-0.02134181559085846,
-0.018... | 0.798113 | 0.781534 | 0.016579 |
You are tasked with implementing a function to convert a given integer into a single-precision floating-point number. The function should take an integer as input and return the corresponding single-precision floating-point number.
Write a function that takes an integer as input and converts it into a single-precision... | glaive | [
0.019562825560569763,
0.03922611474990845,
-0.016431083902716637,
-0.05351897329092026,
0.04713665321469307,
-0.032572850584983826,
-0.010592330247163773,
0.05975385382771492,
0.028211066499352455,
-0.011955020017921925,
0.026911728084087372,
0.030686570331454277,
-0.008627219125628471,
-0... | 0.793297 | 0.777706 | 0.015591 |
You have been tasked with implementing an algorithm for unification to solve symbolic equations problems. The algorithm should take two expressions and a set of variables as input, and look for values that can match the given variables to satisfy the equation. Your task is to write a function or method that can handle ... | glaive | [
0.04331705719232559,
0.01893354021012783,
-0.05179731175303459,
-0.029689857736229897,
0.03506840765476227,
-0.029471417888998985,
-0.0008251859690062702,
0.0731181725859642,
0.04123557731509209,
-0.01091035082936287,
0.026808159425854683,
0.03525305539369583,
0.0019295464735478163,
-0.012... | 0.822512 | 0.795289 | 0.027223 |
You have been tasked with implementing a function in a programming language that takes a set A and a size i, and a function that takes an element of A and a proof that the size of the element is less than the size i, and returns an element of A. The function signature should look like this:
fun f : [A : Set] -> [i : Si... | glaive | [
0.019398652017116547,
0.03373254835605621,
-0.028281766921281815,
-0.0330003947019577,
0.03436855971813202,
-0.04146675765514374,
-0.009419651702046394,
0.07111816853284836,
0.04041100665926933,
-0.023389771580696106,
0.03628820553421974,
0.045865051448345184,
-0.02950250171124935,
-0.0140... | 0.83641 | 0.812083 | 0.024326 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.