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 need to implement a CMeans class that can perform clustering on a dataset using the C-means algorithm. The class should have the following functionalities:
1. Initialize the CMeans class with a list of lists of doubles (x) representing the dataset, and an integer (m) representing the number of clusters.
2. Implemen... | glaive | [
0.01355601754039526,
0.02979082614183426,
-0.037209659814834595,
-0.021292010322213173,
0.04398249462246895,
-0.030299236997961998,
-0.03825794532895088,
0.05092814937233925,
0.03560743108391762,
-0.017786193639039993,
0.01461302675306797,
0.021522976458072662,
-0.012113882228732109,
0.015... | 0.803172 | 0.781672 | 0.0215 |
You are tasked with creating a CUDA program to solve the Breadth-First Search (BFS) problem for a given graph. The graph is represented using the Compressed Sparse Row (CSR) format and consists of M vertices and NNZ edges. The goal is to find the shortest distance from a given source vertex to all other vertices in the... | glaive | [
0.0003465296176727861,
0.041262902319431305,
-0.04019445925951004,
-0.02882963791489601,
0.020189525559544563,
-0.026226630434393883,
-0.0120832659304142,
0.06890389323234558,
0.05996159836649895,
-0.01615367829799652,
0.020616047084331512,
0.03513750061392784,
0.0030319925863295794,
0.006... | 0.805999 | 0.781819 | 0.02418 |
You are given a 2D matrix A of dimensions N*N. Your task is to write a program to return the sum of all possible submatrices of the given matrix.
Constraints:
1 <= N <=30
0 <= A[i][j] <= 10
Input:
A 2-D array A of size N x N.
Output:
An integer denoting the sum of all possible submatrices in the given matrix.
Examp... | glaive | [
0.019494859501719475,
0.012501640245318413,
-0.03150312975049019,
-0.027148574590682983,
0.05948672816157341,
-0.019613223150372505,
-0.028758229687809944,
0.04616512358188629,
0.039747174829244614,
0.004874953534454107,
0.012693911790847778,
0.026177600026130676,
-0.0577596016228199,
-0.0... | 0.81681 | 0.747041 | 0.069769 |
You are tasked with creating a program that utilizes the bessel_first_kind function to transform data and parameters. The program should take input values for d_int, r_int, and d_real, and use them to calculate transformed_data_int, transformed_data_real, transformed_param_real, and y_p. The transformed_data_real and t... | glaive | [
0.013204354792833328,
0.027577579021453857,
-0.014456723816692829,
-0.04882671684026718,
0.035195060074329376,
-0.03267442062497139,
-0.005850930232554674,
0.04768398404121399,
0.035400860011577606,
-0.008918646723031998,
0.004105022642761469,
0.04053007811307907,
-0.024318741634488106,
-0... | 0.795396 | 0.779548 | 0.015848 |
You are tasked with creating a stored procedure in SQL Server to retrieve a specified number of records from the EventStore table with additional information from the EventType table. The stored procedure should take two parameters: @FromSequenceNumber and @EventTypeId. It should return the top N records (where N is a ... | glaive | [
0.04244814068078995,
-0.015191284939646721,
-0.03367416933178902,
-0.0176589023321867,
0.014048738405108452,
-0.03411395102739334,
-0.04387284070253372,
0.059298016130924225,
0.04865404963493347,
0.0070037092082202435,
0.045991286635398865,
0.06786272674798965,
-0.03047667257487774,
0.0183... | 0.779461 | 0.761222 | 0.01824 |
Create a program that calculates the maximum probability of a quantum state, based on the given amplitude and probability functions. The program should also visualize the probability function using a 3D plot and a contour plot. | glaive | [
0.00931633822619915,
0.03126921504735947,
-0.03561010956764221,
-0.03845842182636261,
0.04481179267168045,
-0.02371979132294655,
-0.022557847201824188,
0.07127627730369568,
0.03174680843949318,
-0.004180973395705223,
0.026759427040815353,
0.038304053246974945,
-0.010309305042028427,
-0.009... | 0.788987 | 0.774133 | 0.014854 |
You are tasked with implementing a function to calculate the integral of a given function using Simpson's rule. The function should take in the following parameters:
- f: the function to be integrated
- a: the lower limit of integration
- b: the upper limit of integration
- n: the number of intervals to use in the appr... | glaive | [
0.032283931970596313,
0.024604782462120056,
-0.029431672766804695,
-0.028290318325161934,
0.03421146422624588,
-0.012910627759993076,
-0.025964152067899704,
0.05544352903962135,
0.022121397778391838,
-0.0020688320510089397,
0.022665640339255333,
0.045737165957689285,
-0.019656678661704063,
... | 0.789281 | 0.751974 | 0.037307 |
You are tasked with implementing a program that utilizes the CUDA framework to perform image processing operations. Specifically, you need to write a CUDA C program to perform a pixel-wise multiplication of an input image by a scalar value of 2. The input image will be provided as an input file, and the output image sh... | glaive | [
-0.01777651347219944,
0.05069877207279205,
-0.0072190118953585625,
-0.011460486799478531,
0.01927744410932064,
-0.0053298017010092735,
-0.02877732366323471,
0.11348466575145721,
0.03677491471171379,
-0.031690072268247604,
0.022707359865307808,
0.02447391301393509,
-0.004390978254377842,
-0... | 0.788503 | 0.77169 | 0.016812 |
You are tasked with implementing a function in OCaml that takes in two integer inputs, x and y, and returns the sum of x and y. Additionally, you need to write code to ensure that if the result of the function is not equal to 9, a Not_found exception is raised. | glaive | [
0.004458516836166382,
0.02074337564408779,
-0.03418530523777008,
-0.044811852276325226,
0.03290288522839546,
-0.004597030580043793,
-0.02424207329750061,
0.05183633044362068,
0.05512809008359909,
-0.005790590774267912,
0.04351551830768585,
0.04663315415382385,
-0.01960100792348385,
-0.0115... | 0.817088 | 0.801047 | 0.016041 |
You are tasked with implementing a program that calculates the gamma cumulative distribution function (CDF) for various input parameters. The gamma CDF is a mathematical function that represents the probability of a random variable being less than or equal to a certain value. Your program should take in four input para... | glaive | [
-0.010373643599450588,
0.019517142325639725,
-0.032466743141412735,
-0.036753881722688675,
0.04292421415448189,
-0.019518030807375908,
-0.012776324525475502,
0.06699127703905106,
0.03560711070895195,
-0.010718015022575855,
0.010113869793713093,
0.028478359803557396,
-0.04347596690058708,
0... | 0.808785 | 0.780409 | 0.028375 |
How can I develop a program in C to shuffle an array? | glaive | [
0.00676879845559597,
0.03216738626360893,
-0.026546316221356392,
-0.027282778173685074,
0.032144103199243546,
-0.033057164400815964,
-0.042346879839897156,
0.06660308688879013,
0.027333177626132965,
-0.0370258092880249,
0.01370288711041212,
0.02357555739581585,
-0.04484141245484352,
-0.028... | 0.780796 | 0.766434 | 0.014362 |
You are tasked with writing a program to implement pointer arithmetic and comparisons in a specific programming language. Your task is to write a program that demonstrates the following:
- Dereferencing a pointer and performing arithmetic operations on the dereferenced value
- Using pointer arithmetic to access element... | glaive | [
0.036932554095983505,
0.04305604472756386,
-0.005538646597415209,
-0.013151098042726517,
0.02032376080751419,
-0.048016924411058426,
0.004953598137944937,
0.07616699486970901,
0.04028825834393501,
-0.008554522879421711,
0.015444238670170307,
0.025746570900082588,
-0.03880174458026886,
-0.0... | 0.803709 | 0.776319 | 0.027391 |
What is the algorithm to find the longest common subsequence of two strings? | glaive | [
0.004007788375020027,
0.015898725017905235,
-0.03660638630390167,
-0.03783205896615982,
0.021436139941215515,
-0.02393864467740059,
-0.026919713243842125,
0.032642386853694916,
0.017451973631978035,
-0.04380287602543831,
0.013849576935172081,
0.022887827828526497,
-0.02035428024828434,
-0.... | 0.805559 | 0.774476 | 0.031082 |
You are tasked with implementing a subroutine to perform line solves in the Y direction. The subroutine must first factor the block-tridiagonal matrix into an upper triangular matrix and then perform back substitution to solve for the unknown vectors of each line. The subroutine should treat elements zero to cell_size ... | glaive | [
0.0028327303007245064,
0.026400988921523094,
-0.028906038030982018,
-0.050523944199085236,
0.03773682564496994,
-0.012981601059436798,
-0.00514144217595458,
0.0786399245262146,
0.047003209590911865,
0.0013252724893391132,
0.018196824938058853,
0.051444102078676224,
-0.017926286906003952,
0... | 0.806611 | 0.786616 | 0.019995 |
You are tasked with implementing a CUDA kernel function that generates an identity matrix. The function should take the offset, stripe, output_data, and diag_count as input parameters and populate the output_data with the identity matrix using CUDA parallel processing.
The _EyeLikeKernel function should be designed to... | glaive | [
0.018047749996185303,
0.0444830060005188,
-0.010959385894238949,
-0.02569449134171009,
0.02363610826432705,
-0.0024181914050132036,
-0.02695377729833126,
0.1032341718673706,
0.0454416386783123,
-0.014303596690297127,
0.03062373772263527,
0.021087761968374252,
-0.005060059949755669,
0.00572... | 0.804823 | 0.789624 | 0.015199 |
You are given an array of integers `arr`, and two integers `k` and `x`. Your task is to find the `k` closest elements to the integer `x` in the array. The `k` closest elements are defined as the `k` elements in the array that have the smallest absolute difference with `x`.
Write a function `findClosestElements` that t... | glaive | [
0.04177289083600044,
0.06060665100812912,
-0.022175660356879234,
-0.03206399455666542,
0.04592828452587128,
-0.033761780709028244,
-0.029154621064662933,
0.038962315768003464,
0.054994579404592514,
-0.003755345242097974,
0.03821345418691635,
0.018825436010956764,
-0.018467532470822334,
0.0... | 0.810937 | 0.760052 | 0.050885 |
You are required to implement a CUDA kernel function for a max pooling operation using the given template. The kernel function should perform the forward pass of max pooling on the input data and calculate the maximum value for each pooling region. The output should be stored in the top_data array, and the correspondin... | glaive | [
0.02055368572473526,
0.047239694744348526,
-0.02586335875093937,
-0.013880842365324497,
0.024944700300693512,
-0.017654942348599434,
-0.031390588730573654,
0.07494431734085083,
0.05295073986053467,
-0.0022383679170161486,
0.0337698869407177,
0.04735543206334114,
-0.014421886764466763,
-0.0... | 0.809933 | 0.780584 | 0.029349 |
You are tasked with implementing an implicit finite sequence data structure in OCaml. The data structure should be described by a module that contains enough information to produce an arbitrary element upon request, rather than explicitly representing the sequences of elements in memory. This design imposes constraints... | glaive | [
0.012442114762961864,
0.025713901966810226,
-0.019268274307250977,
-0.03810066729784012,
0.03447575494647026,
-0.03149407356977463,
-0.015629462897777557,
0.06590018421411514,
0.0389571376144886,
-0.008394955657422543,
0.03078710101544857,
0.04791467264294624,
-0.011542374268174171,
-0.008... | 0.811648 | 0.791051 | 0.020596 |
You are tasked with implementing a function that adds elements to a linked list and returns the modified list. The function should take in a linked list and a variable number of elements to add to the list. The function should then add each element to the end of the list and return the modified list. | glaive | [
0.022790519520640373,
0.032451558858156204,
-0.018314138054847717,
-0.047544848173856735,
0.06549209356307983,
-0.033447325229644775,
-0.014780161902308464,
0.06456261873245239,
0.047434914857149124,
0.015032634139060974,
0.02161410264670849,
0.05076214671134949,
-0.03175609931349754,
-0.0... | 0.797859 | 0.782215 | 0.015644 |
You are tasked with implementing a Scheme function that creates an enumeration type and associated operations. The function should take a list of symbols as input and return an enumeration type that supports operations such as checking for membership, subset, equality, union, intersection, difference, and complement.
... | glaive | [
0.06177143752574921,
0.005197436083108187,
-0.02109675481915474,
-0.016401728615164757,
0.0323462188243866,
-0.045111704617738724,
-0.015268859453499317,
0.07232801616191864,
0.04883288964629173,
-0.012935720384120941,
0.03551707789301872,
0.05169321596622467,
-0.01665622554719448,
-0.0141... | 0.807455 | 0.79276 | 0.014695 |
You are tasked with implementing a function called apply_n_times that takes in three parameters: n (an integer), f (a function), and x (an integer). The function should apply the given function f to the integer x, n times in succession, and return the final result. If n is 0, the function should simply return the origi... | glaive | [
0.022608580067753792,
0.033944811671972275,
-0.030477376654744148,
-0.02034514583647251,
0.05313066765666008,
-0.022447174414992332,
-0.0143528301268816,
0.07755118608474731,
0.022508908063173294,
0.014630308374762535,
0.018296504393219948,
0.04190824180841446,
-0.05192127823829651,
-0.023... | 0.820193 | 0.79193 | 0.028264 |
I have written a Python code to count permutations and combinations. The code works fine for smaller numbers but for larger numbers, it is not efficient. I am specifically looking for an optimized way to count combinations. The current method that I am using calls the factorial function which takes too long to compute ... | glaive | [
0.01965521089732647,
0.029718346893787384,
-0.03339744731783867,
-0.0008827746496535838,
0.021012848243117332,
-0.01697436161339283,
-0.04152011126279831,
0.06849037855863571,
0.023401973769068718,
0.0036222899798303843,
-0.0002745328820310533,
0.039497047662734985,
-0.027333814650774002,
... | 0.812382 | 0.787241 | 0.025141 |
Can you provide a solution to remove duplicate numbers from an array? | glaive | [
0.020920323207974434,
0.02095949649810791,
-0.03432450443506241,
-0.02904547192156315,
0.027290815487504005,
-0.04697609692811966,
-0.009289424866437912,
0.0584176741540432,
0.037506621330976486,
-0.038856472820043564,
0.006554929073899984,
-0.0014281546464189887,
-0.03768961504101753,
-0.... | 0.798518 | 0.777514 | 0.021004 |
You are tasked with processing a dataset containing five columns: X, Y, TStamp, Pres., and EndPts. The dataset contains a total of 152 rows. Each row represents a set of values for the respective columns. Your goal is to write a program to process this dataset and perform the following operations:
1. Calculate the ave... | glaive | [
0.010408587753772736,
0.013775023631751537,
-0.05224732682108879,
-0.041120994836091995,
0.04148457199335098,
-0.05036843568086624,
-0.026401551440358162,
0.07118185609579086,
0.049002572894096375,
-0.014302805997431278,
0.03299825266003609,
0.01926380582153797,
-0.026799803599715233,
0.00... | 0.813367 | 0.791643 | 0.021725 |
You are tasked with defining a function to determine the fixed points of a self-map in a programming language that supports manipulation of sets and functions. A fixed point of a function f is a point x such that f(x) = x. Your task is to create a function that takes a self-map f : α → α and returns the set of all fixe... | glaive | [
0.03445238247513771,
0.02863200195133686,
-0.026772644370794296,
-0.037290893495082855,
0.04093798249959946,
-0.037272386252880096,
0.001381504931487143,
0.06162913516163826,
0.04134248197078705,
-0.013456832617521286,
0.01001927349716425,
0.03581585735082626,
-0.019462069496512413,
0.0016... | 0.81434 | 0.79405 | 0.02029 |
I have an integer array and I need to design a function that returns an array of characters. Each character in the resulting array should be at an index corresponding to the sum of indices of the same and the previous element in the input array. Can you help me with this? | glaive | [
0.020053191110491753,
0.03592892736196518,
-0.0320231057703495,
-0.042024724185466766,
0.04791324958205223,
-0.04451018199324608,
-0.03265984728932381,
0.0440027117729187,
0.03038882464170456,
-0.018727464601397514,
0.020738236606121063,
0.021798118948936462,
-0.0445239432156086,
-0.029848... | 0.814807 | 0.788781 | 0.026026 |
You are tasked with implementing a function to find the greatest common divisor of a list of polynomials. The function should handle both univariate and multivariate polynomials.
Your task is to write a function `ezgcd` that takes a list of polynomials and returns the greatest common divisor of the polynomials along w... | glaive | [
0.045365288853645325,
0.03434065356850624,
-0.0170693788677454,
-0.04740523174405098,
0.037343431264162064,
-0.030675677582621574,
-0.013951817527413368,
0.03719707578420639,
0.033792294561862946,
-0.027923468500375748,
0.011163362301886082,
0.024035969749093056,
-0.013590485788881779,
-0.... | 0.817577 | 0.782628 | 0.034949 |
You are tasked with implementing a custom `norm_num` tactic in Lean for simplifying arithmetic expressions in the context of semirings. The goal is to manipulate expressions involving addition, multiplication, and exponentiation of natural numbers and their respective literals. Your task is to create the necessary func... | glaive | [
0.012939990498125553,
0.016146263107657433,
-0.03494963049888611,
-0.042179979383945465,
0.03634393587708473,
-0.022678423672914505,
-0.02282019704580307,
0.0739915519952774,
0.03783300518989563,
-0.011407071724534035,
0.013116306625306606,
0.03364099562168121,
-0.013287343084812164,
-0.01... | 0.807547 | 0.792778 | 0.014769 |
我可以使用Python的statistics库来计算这些数值 [3, 5, 9, 15, 18] 的中位数吗？但要求必须提高时间或空间复杂度需求。 | glaive | [
0.020325209945440292,
0.013837887905538082,
-0.04965463653206825,
-0.02918878197669983,
0.04559069871902466,
-0.010824302211403847,
-0.020835261791944504,
0.042441971600055695,
0.02445344813168049,
-0.027165928855538368,
0.028214050456881523,
0.03912266343832016,
-0.030994340777397156,
-0.... | 0.798366 | 0.784028 | 0.014338 |
You are tasked with creating a Python program to generate a normal quantile-quantile (Q-Q) plot from scratch using pandas. The Q-Q plot is a graphical method for assessing whether a set of observations is approximately normally distributed. Your program should be able to take a set of data as input and output a Q-Q plo... | glaive | [
-0.02940675988793373,
0.007169949356466532,
-0.022138025611639023,
-0.03994179889559746,
0.022384008392691612,
-0.033101003617048264,
-0.013990240171551704,
0.0365188792347908,
0.04829821363091469,
-0.01483588945120573,
0.025379788130521774,
0.027429481968283653,
-0.027976609766483307,
0.0... | 0.793235 | 0.778511 | 0.014724 |
You are given a map represented as a grid of characters, where each character can be either a dot (.) or a hash (#). The goal is to manipulate the map based on the following rules:
- For each point on the map, find the binary digits of its neighboring points.
- Use a translation string to convert these binary digits in... | glaive | [
0.010427972301840782,
0.03570589795708656,
-0.009168099611997604,
-0.03963290527462959,
0.04109179973602295,
-0.04555617645382881,
-0.02236638404428959,
0.05720229819417,
0.03742237761616707,
-0.0032804913353174925,
0.015650231391191483,
0.03867264837026596,
-0.0232649277895689,
-0.0234433... | 0.827969 | 0.799347 | 0.028622 |
You are tasked with characterizing the difference between a symmetric monoidal structure on a preorder without including infinity and a Lawvere metric space, based on a given V-category definition. You should write a program that can identify and explain the distinction between the two concepts in the context of the pr... | glaive | [
0.0031301823910325766,
0.008764494210481644,
-0.017712082713842392,
-0.035523708909749985,
0.03212285414338112,
-0.011431301943957806,
-0.038737207651138306,
0.09100084006786346,
0.05294126272201538,
-0.03150087967514992,
0.010435754433274269,
0.028843844309449196,
-0.007371367886662483,
-... | 0.793222 | 0.777469 | 0.015752 |
You are tasked with implementing a method that counts the number of groups a collection can be divided into based on a given group size. Additionally, you need to implement a method that verifies the elements of each group within the collection based on the group size.
Your task is to write the following two methods:
... | glaive | [
0.02184045873582363,
0.006503157317638397,
-0.021681778132915497,
-0.02122661843895912,
0.045400653034448624,
-0.03330988809466362,
-0.020112834870815277,
0.07090461999177933,
0.032884933054447174,
-0.004648707807064056,
0.008557752706110477,
0.03520098328590393,
-0.024956172332167625,
-0.... | 0.816555 | 0.799227 | 0.017329 |
You are tasked with implementing a PageRank algorithm using the GraphBLAS library in C++. The goal is to compute the PageRank of a given sparse matrix and compare the results with both CPU and GPU implementations.
The algorithm requires the following steps:
1. Parse input arguments including debug mode, transpose, mat... | glaive | [
0.03016766346991062,
0.02249808982014656,
-0.01887478306889534,
-0.019487567245960236,
0.03888798505067825,
-0.010447326116263866,
-0.013813663274049759,
0.08510810881853104,
0.029925145208835602,
-0.019213492050766945,
0.0036736957263201475,
0.032803405076265335,
-0.02062884159386158,
0.0... | 0.805406 | 0.784107 | 0.021299 |
You are tasked with creating a Python program that generates a list of all prime numbers within a given range. Your program should take two input integers, start and end, and return a list of all prime numbers between those two values.
Write a Python function called `generate_primes` that takes two integer parameters,... | glaive | [
0.023769857361912727,
0.02080104872584343,
-0.02495042234659195,
-0.03778932988643646,
0.031301889568567276,
-0.03659914433956146,
-0.014916080981492996,
0.05786014720797539,
0.0370088666677475,
-0.020299768075346947,
0.024997364729642868,
0.046495404094457626,
-0.036360956728458405,
-0.01... | 0.8121 | 0.784453 | 0.027647 |
You are tasked with creating a function in the "references" package that takes in a slice of integers and returns the sum of all the integers in the slice. The function should be named "SumOfIntegers" and should be able to handle both positive and negative integers. The function should also return an error if the input... | glaive | [
0.00580701045691967,
0.021373670548200607,
-0.04926745221018791,
-0.03285692632198334,
0.05341314524412155,
-0.012900971807539463,
-0.007466959301382303,
0.03397871181368828,
0.031500354409217834,
0.0032318965531885624,
0.02574921026825905,
0.04003092646598816,
-0.03219464048743248,
-0.001... | 0.806637 | 0.785784 | 0.020853 |
You are tasked with implementing a program that simulates a series of flashes on a 10x10 grid. The grid is represented by a 2D array, with each element initially set to 0. The program should perform the following steps:
1. Start with all elements in the grid set to 0.
2. For each iteration, increment the value of each... | glaive | [
0.00013504714297596365,
0.034432973712682724,
-0.020405296236276627,
-0.05001578852534294,
0.039929673075675964,
-0.05888325348496437,
-0.023447204381227493,
0.08720976114273071,
0.03675505518913269,
-0.008701653219759464,
0.023901119828224182,
0.019051209092140198,
-0.03998443856835365,
0... | 0.826898 | 0.800131 | 0.026767 |
You are tasked with implementing a function that calculates the hyperbolic tangent of a complex number. The function should take a complex number as input and return the hyperbolic tangent of that number. The hyperbolic tangent of a complex number is calculated differently depending on whether the real part of the numb... | glaive | [
0.0054814741015434265,
0.04643813148140907,
-0.023900311440229416,
-0.021746478974819183,
0.0385647714138031,
-0.016214871779084206,
-0.020873304456472397,
0.07663632929325104,
0.04229305312037468,
-0.009796304628252983,
0.018643002957105637,
0.040561024099588394,
-0.0292376521974802,
0.00... | 0.791697 | 0.770341 | 0.021356 |
You are working with a normed vector space and need to implement a function to calculate the distance between two vectors in the space. You need to create a function that takes two vectors, `u` and `v`, and returns the distance between them, denoted as `nvs_dist u v`. | glaive | [
0.0013935021124780178,
0.01672671176493168,
-0.041168004274368286,
-0.023911921307444572,
0.04838205873966217,
-0.0038867476396262646,
-0.03385277837514877,
0.06561379879713058,
0.052618809044361115,
0.011369251646101475,
0.029317142441868782,
0.038228340446949005,
-0.015843549743294716,
-... | 0.805077 | 0.790084 | 0.014993 |
You have been tasked with implementing a CUDA kernel function in C++ to perform a specific computation on GPU. The function, named EvolveValuesRK2_2_gpu, takes in five arguments: const float *dT, float *outConservative, const float *inConservative, const float *midPointConservative, and float *out.
The function should... | glaive | [
0.006373060867190361,
0.05416882783174515,
-0.018646415323019028,
-0.025487998500466347,
0.03101123496890068,
-0.025590380653738976,
-0.043506331741809845,
0.11647284775972366,
0.05062726140022278,
-0.014893820509314537,
0.03305290266871452,
0.04462238773703575,
-0.020454972982406616,
0.00... | 0.796228 | 0.779659 | 0.016568 |
You are tasked with creating a program that constructs the finest (largest) Grothendieck topology for a given presheaf in a category. The program should define the topology explicitly by specifying its sieves. A sieve `S` on `X` is covering for the finest topology for a presheaf `P` if, for any `f : Y ⟶ X`, `P` satisfi... | glaive | [
0.031051086261868477,
0.023083195090293884,
-0.03361893445253372,
-0.03352607786655426,
0.017346380278468132,
-0.017648721113801003,
-0.023880526423454285,
0.05478256940841675,
0.04512673243880272,
0.0030806821305304766,
0.015182889066636562,
0.03915097564458847,
-0.021402373909950256,
0.0... | 0.806129 | 0.783821 | 0.022308 |
You are required to write a C++ program that calculates the factorial of a given number and also computes the log-Gamma function at a specific point. The program should include the necessary header file "gcem.hpp" and use the functions provided in it to perform these calculations. The factorial of a number can be calcu... | glaive | [
0.006376861594617367,
0.038569312542676926,
-0.005829429719597101,
-0.0378359779715538,
0.03834134712815285,
-0.025929268449544907,
-0.03385409712791443,
0.08830238878726959,
0.02552054636180401,
-0.02330210991203785,
0.011663180775940418,
0.04650164768099785,
-0.03861211612820625,
0.00289... | 0.800383 | 0.773384 | 0.026999 |
You are tasked with implementing a CUDA kernel that performs a reduction operation on an input array. The input array is of size `input_size` and the reduction operation should sum all the elements of the array. The array will be split into blocks and each block will perform a partial reduction. At the end, the partial... | glaive | [
-0.009740689769387245,
0.05606537312269211,
-0.03141375258564949,
-0.019161852076649666,
0.036594927310943604,
-0.005949534475803375,
-0.01625189743936062,
0.09175238013267517,
0.05613476783037186,
-0.0014818323543295264,
0.017453845590353012,
0.029440445825457573,
-0.010775481350719929,
0... | 0.810914 | 0.786578 | 0.024336 |
You are tasked with implementing an eigen solver for a sparse matrix using the lanczos method. The eigen_solver_config_t struct defines the control parameters for the eigen solver, such as the number of eigen vectors to compute, the maximum number of iterations, the tolerance, and whether to reorthogonalize. The lanczo... | glaive | [
0.012641580775380135,
0.030530186370015144,
-0.009230724535882473,
-0.04088087007403374,
0.03890272602438927,
-0.004974002949893475,
-0.006789138074964285,
0.06482870876789093,
0.037801697850227356,
-0.020493216812610626,
0.017216786742210388,
0.042907364666461945,
-0.02447635866701603,
0.... | 0.805634 | 0.787013 | 0.018621 |
You are tasked with implementing a function to convert an array of floating point numbers to a comma-separated list. The function should take the array as input and return a string with the array elements separated by commas. Assume that the input array is non-empty and contains valid floating point numbers.
Write a f... | glaive | [
0.025700299069285393,
0.026927025988698006,
-0.020225049927830696,
-0.04357752948999405,
0.05128476768732071,
-0.04754238948225975,
-0.02359703928232193,
0.0684136152267456,
0.036327898502349854,
-0.03827567398548126,
0.027507297694683075,
0.053549736738204956,
-0.02734619937837124,
-0.020... | 0.807866 | 0.788176 | 0.01969 |
You are working on a project that requires implementing a sparse matrix dense vector multiplication using the Sliced Ellpack format. Your task is to write a CUDA kernel that performs this operation efficiently. The Sliced Ellpack format is a compressed sparse row (CSR) format, where each row is divided into equal-sized... | glaive | [
0.004979776684194803,
0.05725608393549919,
-0.019755788147449493,
-0.024696119129657745,
0.031877655535936356,
0.001285300008021295,
-0.0424276702105999,
0.08296242356300354,
0.03916468843817711,
-0.02453380450606346,
0.014561879448592663,
0.022006919607520103,
-0.0029694305267184973,
0.00... | 0.801957 | 0.784943 | 0.017014 |
You are required to implement a function that takes a binary tree as input and returns a list of its elements in non-decreasing order. The binary tree is represented as a list, with the first element being the entry, the second element being the left branch, and the third element being the right branch. You need to imp... | glaive | [
0.027053141966462135,
0.033628858625888824,
-0.02415410429239273,
-0.041840799152851105,
0.034200020134449005,
-0.028532663360238075,
-0.001972460886463523,
0.08253466337919235,
0.03919780254364014,
-0.0048827207647264,
0.043812502175569534,
0.03258763253688812,
-0.02778542786836624,
0.001... | 0.814684 | 0.788668 | 0.026017 |
You are tasked with implementing a digital signal processing (DSP) system using Xilinx IP cores. The system should include the following components:
1. A slice_0 component, with a DIN_WIDTH of 8, DIN_FROM of 0, DIN_TO of 0, and DOUT_WIDTH of 1.
2. A slice_1 component, with a DIN_WIDTH of 8, DIN_FROM of 1, DIN_TO of 1, ... | glaive | [
0.005195533856749535,
0.01905684545636177,
-0.04547980800271034,
-0.030406227335333824,
0.018813172355294228,
-0.016808344051241875,
-0.016502538695931435,
0.07233095169067383,
0.03554299846291542,
0.002342978259548545,
0.042265232652425766,
0.04633067548274994,
-0.025664804503321648,
-0.0... | 0.794632 | 0.778185 | 0.016447 |
Can an AI design a program that can find all the prime numbers within a specified range? | glaive | [
0.03516487404704094,
0.020641539245843887,
-0.014103860594332218,
-0.031219590455293655,
0.03492654487490654,
-0.050002992153167725,
-0.0124129643663764,
0.05191900208592415,
0.03485478460788727,
-0.0339074581861496,
0.011907832697033882,
0.040546998381614685,
-0.013069330714643002,
-0.024... | 0.792813 | 0.776422 | 0.01639 |
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 and return the calculated area. The input should be provided by the user and the area should be displayed as the output. | glaive | [
0.01866140030324459,
0.05264366418123245,
-0.046071697026491165,
-0.029921190813183784,
0.024493375793099403,
-0.017856258898973465,
-0.026745911687612534,
0.057778023183345795,
0.053286902606487274,
-0.012318786233663559,
0.026899214833974838,
0.05087027698755264,
-0.03180002048611641,
-0... | 0.777671 | 0.74565 | 0.032021 |
You are required to write a CUDA program that generates random passwords using a 62-character alphanumeric charset, containing [a-zA-Z0-9]. The program should also include functions to analyze memory allocation for GPU and CPU, compute batch size, initialize arrays, print signatures, digests, and passwords, create and ... | glaive | [
0.018414853140711784,
0.049156177788972855,
-0.004268297925591469,
-0.02854488603770733,
0.020090825855731964,
-0.02423354797065258,
-0.0278399009257555,
0.05489754676818848,
0.026489747688174248,
-0.03742843121290207,
0.019756119698286057,
0.023598890751600266,
-0.01308483351022005,
-0.01... | 0.807809 | 0.792756 | 0.015053 |
You are tasked with creating a statistical model to estimate the expected number of COVID-19 cases and deaths in different age groups for multiple countries. The model needs to take into account various factors such as contact rates between age groups, population demographics, and prior data on reported deaths by age.
... | glaive | [
0.024110473692417145,
0.0030920705758035183,
-0.05590412765741348,
-0.04928280785679817,
0.04533548653125763,
-0.010379677638411522,
-0.04242413863539696,
0.058399807661771774,
0.03154926002025604,
-0.006509150378406048,
0.013611158356070518,
0.06251266598701477,
-0.016941528767347336,
0.0... | 0.780635 | 0.750824 | 0.029812 |
You are tasked with implementing a forward and backward differences operator to compute second order differences along all dimensions for a given input tensor. The operator needs to be implemented for 2D, 3D, and 4D tensors.
The forward differences operator should calculate the differences between neighboring elements... | glaive | [
0.03742068633437157,
0.021704114973545074,
-0.028608933091163635,
-0.05331127345561981,
0.03404606878757477,
0.0048230537213385105,
-0.03384491056203842,
0.07492935657501221,
0.05489485710859299,
-0.006083487067371607,
0.015855489298701286,
0.04091145470738411,
-0.03159524127840996,
-0.001... | 0.802802 | 0.782203 | 0.020599 |
You are tasked with creating a program to calculate the probability distribution of a quantum system with 16 qubits and 4 states. The amplitude of the system is defined by the functions amplitude[x, y] and amplitude2[x, y], and the probability of obtaining a certain measurement outcome is given by the function probabil... | glaive | [
0.007287021726369858,
0.018827781081199646,
-0.03708937019109726,
-0.02010553702712059,
0.054195500910282135,
-0.030738497152924538,
-0.027006737887859344,
0.06570972502231598,
0.04259971156716347,
-0.00012471100490074605,
0.025736765936017036,
0.03771020099520683,
-0.013463268056511879,
-... | 0.798947 | 0.768034 | 0.030913 |
I'm working on an 80x86 assembly program where I need to calculate the equation (((((2^0 + 2^1) * 2^2) + 2^3) * 2^4) + 2^5)...(2^n). Each even exponent is preceded by a multiplication and each odd exponent is preceded by a plus. I have implemented the code, but my result is continuously off from the desired result. Whe... | glaive | [
0.028771545737981796,
0.029438788071274757,
-0.022473279386758804,
-0.047158319503068924,
0.03080221451818943,
-0.04482865706086159,
-0.03291873633861542,
0.09917236864566803,
0.04357897490262985,
-0.018967412412166595,
0.02999342419207096,
0.03654386103153229,
-0.03372585028409958,
-0.038... | 0.803327 | 0.788573 | 0.014754 |
You are tasked with creating a program to calculate the probability of a quantum state for a given set of qubits. The program should use the given formula to calculate the probability and then optimize it using simulated annealing. Finally, it should visualize the probability using a 3D plot and a contour plot. | glaive | [
-0.0029036281630396843,
0.0315108522772789,
-0.03809068351984024,
-0.018024278804659843,
0.04180439934134483,
-0.02322249487042427,
-0.027543406933546066,
0.07494544982910156,
0.03321176767349243,
-0.009064266458153725,
0.022041233256459236,
0.03594828397035599,
-0.012994819320738316,
-0.0... | 0.799181 | 0.772724 | 0.026457 |
You are tasked with implementing a CUDA kernel function to perform reduction operations on an array of floating-point numbers. The reduction operation can be either a sum or an average, based on a boolean flag. The forward kernel function should compute the reduction result and store it in a single-element array, while... | glaive | [
-0.008972386829555035,
0.04809829592704773,
-0.02014739252626896,
-0.027099529281258583,
0.040166035294532776,
-0.008425401523709297,
-0.018530473113059998,
0.10722552239894867,
0.0564444400370121,
-0.0004405027430038899,
0.019244302064180374,
0.044968053698539734,
-0.012969547882676125,
0... | 0.809683 | 0.789629 | 0.020055 |
You are tasked with creating a data structure in C++ that includes a variety of different types of containers and nested structures. The data structure should include the following components:
- A map of strings to 64-bit integers
- A sub-structure with an integer and a string
- A union with a string
- A set of strings... | glaive | [
0.01942072995007038,
0.009137029759585857,
-0.02063898742198944,
-0.019007641822099686,
0.05574452504515648,
-0.024625267833471298,
-0.016095764935016632,
0.08912204205989838,
0.03669639676809311,
-0.01778060756623745,
0.03006029687821865,
0.033623211085796356,
-0.03028762713074684,
-0.016... | 0.802832 | 0.771838 | 0.030994 |
You are tasked with implementing a function in the programming language that computes the difference between two natural numbers. The function should take two non-negative integers as input and return their difference. You are not allowed to use any built-in subtraction operator or function, and you must use only the b... | glaive | [
0.029165660962462425,
0.030367255210876465,
-0.020017750561237335,
-0.024855686351656914,
0.04892943054437637,
-0.017774134874343872,
-0.02903575822710991,
0.06325867027044296,
0.06831274181604385,
-0.010704826563596725,
0.029562868177890778,
0.03153569996356964,
-0.038007840514183044,
-0.... | 0.810913 | 0.784159 | 0.026754 |
You are required to implement a CUDA kernel function that sets the range of a given array of double values based on the provided parameters. The CUDA kernel function should take in the number of elements in the array, the starting index, the array of double values, the increment value for accessing the array, the param... | glaive | [
0.010440048761665821,
0.051300644874572754,
-0.019594786688685417,
-0.024923181161284447,
0.027819843962788582,
-0.02223016507923603,
-0.04008655622601509,
0.08524619042873383,
0.04370690509676933,
-0.018643608316779137,
0.027851544320583344,
0.04234503582119942,
-0.017398934811353683,
0.0... | 0.801785 | 0.778215 | 0.02357 |
You are tasked with implementing a mutable binary tree data structure using structs in Racket. This structure should consist of two types of nodes: leaf nodes, which have a single value, and branch nodes, which have left and right child nodes. Additionally, you need to define two destructive operations for binary trees... | glaive | [
0.015896206721663475,
0.031716473400592804,
-0.03297501429915428,
-0.02323742024600506,
0.04380740225315094,
-0.04547544941306114,
0.0040488881058990955,
0.08084523677825928,
0.04211423173546791,
-0.004228325095027685,
0.02059444785118103,
0.02939804084599018,
-0.024819333106279373,
0.0035... | 0.806345 | 0.78509 | 0.021255 |
You are required to create a Delphi program that can evaluate arithmetic expressions with arbitrary precision floating point numbers. The program should be able to parse an expression, calculate the value, and handle errors such as overflow and underflow.
Your program should be able to handle the following arithmetic ... | glaive | [
0.02922283113002777,
0.01666947454214096,
-0.008929279632866383,
-0.05346612632274628,
0.048105426132678986,
-0.03771553933620453,
-0.00949171744287014,
0.06564663350582123,
0.04669998213648796,
-0.008165974169969559,
0.03588450700044632,
0.03198085352778435,
-0.024547725915908813,
-0.0282... | 0.795397 | 0.776665 | 0.018732 |
You are tasked with creating a program that calculates the probability of a quantum state for a given set of parameters. The program should use the provided amplitude and probability functions to calculate the probability and then use NMaximize to find the maximum probability for a certain range of values. Finally, the... | glaive | [
0.004998199176043272,
0.026744041591882706,
-0.03505201265215874,
-0.021025018766522408,
0.049648623913526535,
-0.023079192265868187,
-0.01682901941239834,
0.07791092991828918,
0.03543455898761749,
0.003046612720936537,
0.03229399397969246,
0.04453176632523537,
-0.023376375436782837,
-0.01... | 0.794309 | 0.772546 | 0.021763 |
You are required to write a program to calculate the probability of a quantum state. The program should implement the following functions:
1. `amplitude[x, y]`: This function takes two parameters `x` and `y` and returns a complex number.
2. `amplitude2[x, y]`: This function also takes two parameters `x` and `y` and ret... | glaive | [
0.0001383289200020954,
0.0374545119702816,
-0.02571898140013218,
-0.0239631999284029,
0.04093445837497711,
-0.018340658396482468,
-0.009719343855977058,
0.06547284871339798,
0.03683952987194061,
0.0037709565367549658,
0.029417406767606735,
0.03658106178045273,
-0.017116166651248932,
-0.016... | 0.793421 | 0.765694 | 0.027727 |
You are tasked with creating a function in a statistical programming language that calculates the natural logarithm of the Cauchy probability density function (PDF). The function should take a single input parameter, x, and return the value of the natural logarithm of the Cauchy PDF at that point. The Cauchy PDF is def... | glaive | [
-0.00506097124889493,
0.036848630756139755,
-0.04062776267528534,
-0.029843056574463844,
0.0393078587949276,
-0.0056041209027171135,
-0.019761579111218452,
0.059145379811525345,
0.03419208526611328,
-0.005213493946939707,
0.011552176438272,
0.031060008332133293,
-0.009884696453809738,
-0.0... | 0.807456 | 0.791268 | 0.016188 |
You are tasked with implementing a program that solves a system of linear equations AX = B for X. The upper or lower triangular part of the matrix A is read from a data file, along with the matrix B. The program should then use the function zhpsvx to solve the system of equations and print the solution, error bounds, a... | glaive | [
0.0283784419298172,
0.019087934866547585,
-0.036774344742298126,
-0.039812054485082626,
0.056148163974285126,
-0.026701943948864937,
0.0004930120776407421,
0.07241818308830261,
0.04574774205684662,
-0.029993239790201187,
0.018455926328897476,
0.03185569867491722,
-0.009672281332314014,
-0.... | 0.807371 | 0.783782 | 0.023588 |
You are tasked with implementing a function that calculates the value of a sequence using the following recurrence relation:
a(n) = 2*a(n-1) + 4*a(n-2) with n>1, a(0)=0, a(1)=4.
You should write a function that takes an integer n as input and returns the value of a(n) based on the given recurrence relation. | glaive | [
0.034788575023412704,
0.05270777642726898,
-0.025205932557582855,
-0.02931956574320793,
0.03599739447236061,
-0.010100291110575199,
-0.021518835797905922,
0.07812508940696716,
0.040946636348962784,
0.0048516178503632545,
0.019372671842575073,
0.03842135891318321,
-0.025603273883461952,
-0.... | 0.823453 | 0.772912 | 0.050541 |
You are tasked with creating a program that calculates the probability of a quantum state using a given amplitude function. The amplitude function is defined as:
amplitude[x_,y_] := (Exp[-15 I y] * (1 * (I * Sin[x])^6 * Cos[x]^10 + 1 * (I * Sin[x])^10 * Cos[x]^6) + ... + Exp[15 I y] * (1 * (I * Sin[x])^4 * Cos[x]^12 + ... | glaive | [
0.0032451865263283253,
0.03432215377688408,
-0.029906077310442924,
-0.031770627945661545,
0.039922118186950684,
-0.02191634476184845,
-0.01693115197122097,
0.07638874650001526,
0.031195441260933876,
0.005103853531181812,
0.0304835457354784,
0.03231322765350342,
-0.017367558553814888,
-0.01... | 0.793643 | 0.765834 | 0.027809 |
You are tasked with creating a program that calculates the probability of a quantum state given by the `amplitude` function. The `amplitude` function takes two parameters `x` and `y` and returns a complex value. The `probability` function calculates the absolute square of the amplitude. Additionally, the program should... | glaive | [
0.0035860755015164614,
0.0364358127117157,
-0.03180257976055145,
-0.02217688038945198,
0.040901027619838715,
-0.02935905009508133,
-0.016561930999159813,
0.07757750898599625,
0.03288482129573822,
0.006496175192296505,
0.025277867913246155,
0.04263070970773697,
-0.023737166076898575,
-0.012... | 0.795721 | 0.768527 | 0.027195 |
You are tasked with implementing a function to sort an array of integers in descending order. The function should take an array of integers as input and return a new array with the integers sorted in descending order. You are not allowed to use any built-in sorting functions.
Write a function called `descendingSort` t... | glaive | [
0.016947871074080467,
0.034949179738759995,
-0.024229418486356735,
-0.03332480788230896,
0.03920905292034149,
-0.02841845713555813,
-0.018107987940311432,
0.045449938625097275,
0.03897463157773018,
-0.002755245892331004,
0.01576095074415207,
0.0018582155462354422,
-0.048443131148815155,
0.... | 0.797092 | 0.752425 | 0.044667 |
I need help with finding the maximum product of two numbers from an array of numbers in Python. Can you provide a solution? | glaive | [
0.017361711710691452,
0.026815176010131836,
-0.033778637647628784,
-0.020772995427250862,
0.03295399248600006,
-0.020580390468239784,
-0.030003827065229416,
0.03926404193043709,
0.03047233447432518,
-0.03086770884692669,
0.0030352910980582237,
0.02698517218232155,
-0.024997767060995102,
-0... | 0.801055 | 0.783987 | 0.017068 |
You are tasked with creating a Dart library that includes a function to calculate the factorial of a given number. The factorial of a non-negative integer n is the product of all positive integers less than or equal to n. For example, the factorial of 5 is 5 * 4 * 3 * 2 * 1 = 120. You need to implement a function that ... | glaive | [
0.021238218992948532,
0.02452266216278076,
-0.017878718674182892,
-0.04101080819964409,
0.048535093665122986,
-0.03846670687198639,
-0.034513697028160095,
0.047899920493364334,
0.04551427438855171,
-0.014411034062504768,
0.004051062278449535,
0.044322751462459564,
-0.04209575802087784,
-0.... | 0.80636 | 0.7806 | 0.02576 |
You are tasked with creating a Julia program to solve the 1D Heisenberg Hamiltonian problem. The program should be able to calculate the energy eigenvalues and eigenvectors for a given spin (S) and particle number (N). The system can have periodic boundary conditions (PBC) or no PBC and the user should be able to speci... | glaive | [
-0.0044650849886238575,
0.036399826407432556,
-0.007763672154396772,
-0.036491796374320984,
0.03997974097728729,
-0.04161090776324272,
-0.020682625472545624,
0.0692194253206253,
0.03878498077392578,
-0.008362133987247944,
0.02085503563284874,
0.037875160574913025,
-0.03686095401644707,
-0.... | 0.803694 | 0.780585 | 0.023108 |
You are tasked with writing a function to calculate the number of possible paths a car can take in a square grid. The car starts at position (0, 0) and the destination is at position (n - 1, n - 1). The car can only move up/North or right/East one square at a time and cannot cross the diagonal (i.e., if at point (i, j)... | glaive | [
0.01827767863869667,
0.017336754128336906,
-0.01608295366168022,
-0.022604892030358315,
0.025550097227096558,
-0.017057836055755615,
-0.030148250982165337,
0.06673567742109299,
0.03129415586590767,
0.00042109223431907594,
0.019116930663585663,
0.041520748287439346,
-0.03991211578249931,
-0... | 0.837398 | 0.772257 | 0.065141 |
You are tasked with implementing a simulation of a Godunov ring using the Julia programming language. The ring consists of a specified number of cells (NN) and the simulation is to be run for a specific number of time steps (Nt). The simulation should also plot the state of the ring at regular intervals, with the plott... | glaive | [
-0.01842453144490719,
0.03298721835017204,
-0.029196228832006454,
-0.03954131156206131,
0.02449294552206993,
-0.04091707989573479,
-0.026288021355867386,
0.09259794652462006,
0.030516769737005234,
-0.01515281107276678,
0.023236852139234543,
0.03610743582248688,
-0.018321692943572998,
0.015... | 0.794881 | 0.776808 | 0.018073 |
You are tasked with implementing a function to check if the rank of a tensor meets certain criteria for reduction. The function should take two parameters: `reduce_rank` and `rank`. The function should return true if the `reduce_rank` is valid for the given `rank`, otherwise it should throw an exception.
The criteria... | glaive | [
0.019312236458063126,
0.024853818118572235,
-0.02381015755236149,
-0.03491734713315964,
0.047113578766584396,
0.0011164973257109523,
-0.005468683782964945,
0.10356472432613373,
0.041715480387210846,
-0.001502755912952125,
0.006923055276274681,
0.02912409044802189,
-0.012820283882319927,
0.... | 0.82352 | 0.795936 | 0.027584 |
You are tasked with writing a program that takes three integer inputs (n, a, b) and calculates the result of the expression n * a * b * 2. Your program should take the inputs from the user, perform the calculation, and then print the result. Ensure that the program handles any type of integer input and produces the cor... | glaive | [
0.05511751398444176,
0.032213639467954636,
-0.05160218104720116,
-0.03248004987835884,
0.04204200580716133,
-0.023229213431477547,
-0.014336980879306793,
0.05779218673706055,
0.046794917434453964,
-0.007400659844279289,
0.025446832180023193,
0.056436728686094284,
-0.02951028384268284,
-0.0... | 0.821954 | 0.789519 | 0.032436 |
You are tasked with creating a SecretTree data structure that will be used for encryption and decryption in a secure communication protocol. The SecretTree needs to handle the generation and retrieval of encryption secrets for different leaf indices and secret types. The generation should be correctly incremented, and ... | glaive | [
0.01271678414195776,
0.030321767553687096,
-0.03946211561560631,
-0.05360692739486694,
0.03257798030972481,
-0.04840429127216339,
-0.018879786133766174,
0.07192619889974594,
0.03242532163858414,
-0.026523832231760025,
0.03602110967040062,
0.0004981031524948776,
-0.03581445291638374,
0.0102... | 0.802753 | 0.778962 | 0.023791 |
You are required to create a CUDA kernel that performs a stencil operation on an array. The stencil operation involves calculating the sum of products of elements in a sliding window and a corresponding set of weights.
You need to implement a CUDA kernel function that takes in two arrays `src` and `dst`, each of size ... | glaive | [
-0.0006788950995542109,
0.05310804024338722,
-0.01887175813317299,
-0.021105187013745308,
0.038230154663324356,
-0.014960655011236668,
-0.04442334920167923,
0.10108361393213272,
0.04401423782110214,
-0.01918977126479149,
0.04974861443042755,
0.03958407789468765,
-0.005607074126601219,
0.01... | 0.81047 | 0.785412 | 0.025058 |
You are tasked with writing a program to process a dataset containing three columns of numerical values. The first column represents the x-coordinate, the second column represents the y-coordinate, and the third column represents the weight of each data point. Your program needs to calculate the weighted average of the... | glaive | [
-0.004392384551465511,
0.008855671621859074,
-0.04772448539733887,
-0.051491737365722656,
0.05176600068807602,
-0.02258504368364811,
-0.015624250285327435,
0.060155633836984634,
0.04266113042831421,
-0.019599124789237976,
0.030790206044912338,
0.026973895728588104,
-0.03782844915986061,
-0... | 0.801651 | 0.782093 | 0.019558 |
You are tasked with implementing a program that calculates the probability of a quantum state in a given quantum circuit. The probability is determined by the amplitude of the state, which is a complex-valued function of two variables, x and y. The amplitude is calculated using a specific formula and is then used to ca... | glaive | [
-0.002923134947195649,
0.028414983302354813,
-0.0391262024641037,
-0.022474512457847595,
0.04461497813463211,
-0.022666404023766518,
-0.02278992533683777,
0.0780179351568222,
0.03256388381123543,
0.000058395609812578186,
0.0272979773581028,
0.039847929030656815,
-0.013124225661158562,
-0.0... | 0.792159 | 0.763997 | 0.028161 |
You are tasked with implementing a subroutine to apply loads distributed over edges in a finite element analysis program. The subroutine takes as input the number of edges, the type of element, the dimensionality, the number of degrees of freedom, the number of nodes, and other relevant parameters. It then iterates ove... | glaive | [
0.016552260145545006,
0.011549794115126133,
-0.024454813450574875,
-0.05549934133887291,
0.04839717224240303,
-0.02530941180884838,
0.008770810440182686,
0.06809407472610474,
0.027513964101672173,
0.00668154563754797,
0.029926210641860962,
0.03214523196220398,
-0.028124019503593445,
0.0040... | 0.802215 | 0.787893 | 0.014322 |
You have a long flowerbed in which some of the plots are planted, and some are not. However, flowers cannot be planted in adjacent plots. Given an integer array flowerbed containing 0's and 1's, where 0 means empty and 1 means not empty, and an integer n, you need to write a function to determine if n new flowers can b... | glaive | [
0.007796733174473047,
0.018114672973752022,
-0.023292073979973793,
-0.01673092134296894,
0.02877526544034481,
-0.02917518839240074,
-0.02108997106552124,
0.07271129637956619,
0.024048829451203346,
-0.01731032133102417,
-0.0020067805889993906,
0.011488063260912895,
-0.022970447316765785,
-0... | 0.833469 | 0.790208 | 0.043261 |
You are tasked with writing a query to find the product of two values of type xsd:decimal and determine if the result is of type xsd:integer. The query should retrieve the values of t:short1 rdf:value ?l and t:short1 rdf:value ?r, calculate their product, and then filter the result to check if the datatype of the produ... | glaive | [
0.020441418513655663,
0.02182433381676674,
-0.05277638137340546,
-0.037468843162059784,
0.0423157699406147,
-0.025488201528787613,
-0.0053451210260391235,
0.0772964209318161,
0.06587569415569305,
-0.02666652575135231,
0.017961453646421432,
0.02701430395245552,
-0.0213464442640543,
-0.02582... | 0.803603 | 0.789182 | 0.014421 |
You are tasked with analyzing admission data for different departments and genders in a university. The dataset "admissionberk" contains information on the number of applications, admitted, and rejected candidates for each department and gender. The goal is to identify and analyze any potential paradoxes, such as Simps... | glaive | [
0.008098685182631016,
0.007241326849907637,
-0.039694271981716156,
-0.051874976605176926,
0.016810158267617226,
-0.006345894653350115,
-0.013843921944499016,
0.06535053253173828,
0.033117908984422684,
0.01674446277320385,
0.013264107517898083,
0.01943146251142025,
-0.0034866828937083483,
0... | 0.78397 | 0.767211 | 0.01676 |
You are tasked with implementing a function that checks for equality between two rows from two tables using CUDA and C++. The task involves creating a function that compares two rows from different tables and returns true if the two rows are element-wise equal. The function should also include an option to specify whet... | glaive | [
0.0223529152572155,
0.020666569471359253,
-0.040254998952150345,
-0.01760406233370304,
0.027645181864500046,
-0.018261700868606567,
-0.0010495418682694435,
0.10283637791872025,
0.051439717411994934,
-0.025217397138476372,
0.01588466763496399,
0.019647326320409775,
0.010558956302702427,
0.0... | 0.801734 | 0.783352 | 0.018382 |
You are tasked with implementing a CUDA kernel function that calculates the self-product of a matrix and updates a new matrix with the result. The function signature is as follows:
```c
extern "C" __global__ void selfProduct(float_ty* mLet, float_ty* newMLet, int rowCount, int colCount, int sz, int* offsets)
```
Where:... | glaive | [
0.005856633186340332,
0.05052083358168602,
-0.019043542444705963,
-0.027521878480911255,
0.03530928120017052,
-0.010495917871594429,
-0.03710508719086647,
0.10260231047868729,
0.048635367304086685,
-0.015944713726639748,
0.020263370126485825,
0.03090173751115799,
-0.009204821661114693,
-0.... | 0.801926 | 0.781011 | 0.020915 |
You are tasked with creating a program that takes in a list of integers and returns the sum of all the even numbers in the list. Your program should be able to handle both positive and negative integers.
Write a function called "sum_even_numbers" that takes in a list of integers as input and returns the sum of all the... | glaive | [
0.02411486953496933,
0.015363847836852074,
-0.03833620622754097,
-0.05096299573779106,
0.04079750180244446,
-0.01320993434637785,
-0.010503871366381645,
0.0339575856924057,
0.03199628368020058,
-0.02588987722992897,
0.014803074300289154,
0.04775441810488701,
-0.04835277050733566,
-0.021539... | 0.811235 | 0.760754 | 0.050481 |
You have been tasked with writing a function to calculate the area of a circle, given its radius. The formula to calculate the area of a circle is A = π * r^2, where A is the area and r is the radius. The value of π is 3.14159. Write a function in Common Lisp to calculate the area of a circle using the given formula. | glaive | [
0.001217567129060626,
0.0486464649438858,
-0.02773534692823887,
-0.047115083783864975,
0.042708322405815125,
-0.033409859985113144,
-0.023801157251000404,
0.029612908139824867,
0.05130480229854584,
0.010695023462176323,
0.03527339547872543,
0.030088070780038834,
-0.02850564941763878,
-0.02... | 0.772361 | 0.754742 | 0.017619 |
I am working on a programming challenge called "Binary Representation Circular Permutation". The task is to generate a permutation `p` of the sequence `(0,1,2.....,2^n -1)`, given two integers `n` and `start`. Can you provide me with a solution to this problem?
The conditions for the permutation `p` are as follows:
1.... | glaive | [
0.0017984359292313457,
0.03578145429491997,
-0.018174828961491585,
-0.02510003000497818,
0.03574284166097641,
-0.030997199937701225,
-0.02779962122440338,
0.08200680464506149,
0.03387836739420891,
-0.0161405261605978,
0.0271757785230875,
0.017646770924329758,
-0.018638411536812782,
-0.0098... | 0.831176 | 0.775821 | 0.055356 |
What is the Python solution to the given leetcode problem? | glaive | [
-0.008897902444005013,
0.020789293572306633,
-0.025601569563150406,
-0.043504748493433,
0.031624551862478256,
-0.015397770330309868,
-0.007810015231370926,
0.04871727153658867,
0.046651631593704224,
-0.02609301172196865,
0.00969655904918909,
0.026844313368201256,
-0.01681928150355816,
0.00... | 0.835291 | 0.817671 | 0.01762 |
You are tasked with counting the number of triangles that can be formed on a 4 X n grid. The grid consists of 4 rows and n columns, and the goal is to determine the total number of triangles that can be formed using the grid lines as the edges of the triangles. Each triangle must have one vertex at the intersection of ... | glaive | [
0.0051704696379601955,
0.01843678019940853,
-0.02471834048628807,
-0.02742648497223854,
0.04225204139947891,
-0.021029332652688026,
-0.04075797274708748,
0.052128419280052185,
0.036901406943798065,
0.0051053655333817005,
0.015146027319133282,
0.046702053397893906,
-0.02149275690317154,
-0.... | 0.817272 | 0.756985 | 0.060288 |
You are tasked with implementing a CUDA kernel for reducing operations on tensors. The goal is to create CUDA kernels for reducing the maximum, minimum, and sum of elements in a tensor, both globally and along a specific dimension. Additionally, you need to implement CUDA kernels for matrix multiplication, setting a te... | glaive | [
0.006456386297941208,
0.045534398406744,
-0.03279484808444977,
-0.019519632682204247,
0.03823421522974968,
-0.0006886437768116593,
-0.014578277245163918,
0.08607269823551178,
0.050150103867053986,
-0.008283071219921112,
0.014754422940313816,
0.02954016998410225,
-0.006544109433889389,
0.00... | 0.801568 | 0.783585 | 0.017982 |
You are given a string, and your task is to sort it in decreasing order based on the frequency of characters.
Create a function that takes a string as input and returns the sorted string based on the frequency of characters.
For example:
Input:
"tree"
Output:
"eert"
Explanation:
'e' appears twice while 'r' and 't' ... | glaive | [
0.03099244274199009,
0.030718514695763588,
-0.008193792775273323,
-0.044726017862558365,
0.03202756494283676,
-0.011170879937708378,
-0.0017269132658839226,
0.05539441853761673,
0.0034253918565809727,
-0.005190668161958456,
0.012971856631338596,
0.017565656453371048,
-0.038015831261873245,
... | 0.811069 | 0.760058 | 0.05101 |
You are tasked with implementing a subroutine in Fortran that sorts a list of feff files based on specific criteria. The subroutine should take as input the number of feff files (mfiles), the number of paths (mpaths), an array of feff file names (feffil), an array of feff file records (iffrec), and an array of path ind... | glaive | [
0.012767886742949486,
0.003737060120329261,
-0.007936184294521809,
-0.03212136775255203,
0.04262654110789299,
-0.013979279436171055,
-0.004395122639834881,
0.035117488354444504,
0.029905391857028008,
0.001943365903571248,
0.008466009981930256,
0.042104460299015045,
-0.04619716852903366,
0.... | 0.801985 | 0.781616 | 0.020369 |
Can someone help me write a program to calculate the factorial of a given number? | glaive | [
0.013657228089869022,
0.03435176610946655,
-0.02493218332529068,
-0.030635904520750046,
0.0332820788025856,
-0.04723837599158287,
-0.023728536441922188,
0.0458834245800972,
0.04517245665192604,
-0.03542809933423996,
0.01883595623075962,
0.042841631919145584,
-0.06084878370165825,
-0.019784... | 0.798901 | 0.784555 | 0.014346 |
You are given a string of comma-separated numbers. Your task is to write a function to calculate two different solutions for the given input:
1. The first solution should calculate the product of all the numbers in the input string.
2. The second solution should calculate the sum of the squares of all the numbers in th... | glaive | [
0.01394670270383358,
0.04113152250647545,
-0.035820916295051575,
-0.03898222744464874,
0.04956364259123802,
-0.03225301206111908,
0.00014612269296776503,
0.05908579006791115,
0.0522778183221817,
-0.021948961541056633,
0.018371541053056717,
0.03735188767313957,
-0.03550194576382637,
-0.0435... | 0.820317 | 0.796177 | 0.024141 |
I am trying to determine whether a given binary relation is single-valued or not. A single-valued binary relation is one in which for every element x in the domain, there is only one element y in the co-domain such that (x, y) is in the relation. I need to write a function to check if a given relation is single-valued ... | glaive | [
-0.0036271559074521065,
0.03997703641653061,
-0.030009860172867775,
-0.021300464868545532,
0.04814133420586586,
-0.01240861788392067,
0.014827239327132702,
0.0851234495639801,
0.0394178181886673,
-0.004170286934822798,
0.021743293851614,
0.021096499636769295,
0.021403782069683075,
-0.00866... | 0.793712 | 0.77409 | 0.019621 |
What is an efficient Java sorting algorithm that I can use? | glaive | [
0.014868296682834625,
0.006831396371126175,
-0.031984344124794006,
-0.024209050461649895,
0.008111017756164074,
-0.035667065531015396,
-0.03370314836502075,
0.031127039343118668,
0.029600592330098152,
-0.04262784868478775,
0.022826919332146645,
0.02148752473294735,
-0.04148394986987114,
-0... | 0.780987 | 0.765375 | 0.015612 |
You are tasked with creating a histogram of the number of targets used in a project. You have the following data:
- slices: a vector containing the number of targets used for each category
- lbls: a vector containing the labels for each category
Create a bar plot with the number of targets on the y-axis and the catego... | glaive | [
-0.0007575972122140229,
0.01575671136379242,
-0.06707662343978882,
-0.014619419351220131,
0.03108889050781727,
-0.019518082961440086,
-0.040329042822122574,
0.04635123535990715,
0.03393320366740227,
-0.017369281500577927,
0.012695617973804474,
0.02873649261891842,
-0.0257971603423357,
-0.0... | 0.78496 | 0.770622 | 0.014338 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.