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 creating a function that generates a graph based on a given mathematical function. The function should prompt the user to input the mathematical function to graph, the starting and ending x values, and the plotting string. The graph should be plotted according to the given input.
Write a function c... | glaive | [
0.03115948475897312,
0.03455303981900215,
-0.050544969737529755,
-0.04779793322086334,
0.04429231584072113,
-0.034134622663259506,
-0.03497488051652908,
0.05775751173496246,
0.05105399340391159,
-0.016922645270824432,
0.00554011482745409,
0.037254154682159424,
-0.01120054628700018,
-0.0106... | 0.792409 | 0.770419 | 0.02199 |
You are tasked with implementing a function that takes in two vectors of integers and returns a new vector containing only the elements that are present in both input vectors. In other words, you need to find the intersection of the two input sets of integers and return it as a new vector.
Write a function called `fin... | glaive | [
0.046909622848033905,
0.028097059577703476,
-0.02365218661725521,
-0.026813184842467308,
0.03977713733911514,
0.016602681949734688,
-0.03177580237388611,
0.06817585229873657,
0.051093991845846176,
-0.009780513122677803,
0.011911376379430294,
0.0003652054874692112,
0.0012793695786967874,
-0... | 0.810062 | 0.765451 | 0.044611 |
You are tasked with creating a program that utilizes the OpenCASCADE set factory to define a geometric model and generate a mesh. The specific requirements are as follows:
- Define a rectangular domain with dimensions L=0.500000 and W=0.500000.
- Create a circular shape with a center at (xpzt, ypzt) and a radius of r=0... | glaive | [
0.017448648810386658,
0.04380258545279503,
-0.013342490419745445,
-0.04079926386475563,
0.02703094854950905,
-0.024921642616391182,
-0.04089881107211113,
0.06122951582074165,
0.03461011126637459,
-0.003794583026319742,
0.03496861085295677,
0.026945028454065323,
-0.010221753269433975,
-0.00... | 0.785583 | 0.762746 | 0.022837 |
You are tasked with implementing the Alternating Directions Algorithm to find a feasible point in the intersection of 2 convex sets A and B. The algorithm relies on a fixed point argument, stopping when it finds a fixed point.
For this problem, consider the sets A={ (x,y) | x=y} and B = {(x,y) | y=0}. The unique inter... | glaive | [
0.01432577520608902,
0.017310643568634987,
0.0007289316854439676,
-0.014918634667992592,
0.015384607017040253,
-0.004976493306457996,
-0.03705841302871704,
0.05570283159613609,
0.06678056716918945,
-0.01364922896027565,
-0.0008528551552444696,
0.00879253726452589,
-0.01383266318589449,
-0.... | 0.814523 | 0.778781 | 0.035742 |
You are tasked with implementing a function to solve the 0-1 knapsack problem and the complete/infinite knapsack problem using Julia programming language. The 0-1 knapsack problem involves finding the most valuable combination of items to fit into a knapsack with a fixed capacity, where each item can only be selected o... | glaive | [
0.005712345242500305,
0.04986996948719025,
-0.0169206615537405,
-0.018648361787199974,
0.04250938817858696,
-0.01578827016055584,
-0.015602581202983856,
0.0651608482003212,
0.03110773116350174,
-0.0002649649977684021,
0.02055680751800537,
0.021931124851107597,
-0.02753615751862526,
0.00846... | 0.823764 | 0.789414 | 0.03435 |
You are tasked with implementing an iterative linear solver in Fortran using the IterativeLinearSolverM module. Your goal is to create a procedure that solves a linear system of equations using a specified preconditioner.
You will need to define a new type that extends the IterativeLinearSolverDT type and implement th... | glaive | [
0.014123551547527313,
0.015541725791990757,
-0.036452844738960266,
-0.06407029181718826,
0.05672655999660492,
-0.021182062104344368,
-0.009141004644334316,
0.08253219723701477,
0.04354838654398918,
-0.009214899502694607,
0.01605401374399662,
0.04975583031773567,
-0.02782808616757393,
-0.01... | 0.796129 | 0.780388 | 0.01574 |
You are tasked with creating a Verilog module that performs a left shift operation on a 16-bit input. The module should take a 4-bit input and shift a 16-bit hexadecimal value left by the specified number of bits. For example, when the input is 4'b0000, the output should be the same as the input. When the input is 4'b0... | glaive | [
0.021438119933009148,
0.030190110206604004,
-0.019434740766882896,
-0.03023219108581543,
0.039097584784030914,
-0.01581883803009987,
-0.030826037749648094,
0.07057632505893707,
0.042839180678129196,
-0.025796543806791306,
0.03362033888697624,
0.03129751980304718,
-0.012673543766140938,
-0.... | 0.791242 | 0.774624 | 0.016618 |
You are tasked with sorting the iris dataset in ascending order based on the Sepal.Length column and displaying the first 'r numlist' observations. The 'numlist' parameter represents the number of observations to be displayed, and the dataset must be sorted in ascending order.
Write a program to achieve this task usi... | glaive | [
0.0016587295103818178,
0.020104169845581055,
-0.014334641396999359,
-0.033920805901288986,
0.022007083520293236,
-0.02432188391685486,
-0.037975676357746124,
0.06538509577512741,
0.047328755259513855,
-0.0038493042811751366,
0.009601449593901634,
0.027140047401189804,
-0.04595063999295235,
... | 0.80368 | 0.784757 | 0.018923 |
You are tasked with creating a program that takes in a list of numbers and returns the sum of all the positive numbers in the list. You should also handle cases where the list is empty or contains only negative numbers.
Write a function called `sumPositiveNumbers` that takes in a list of numbers as a parameter and ret... | glaive | [
0.0124332495033741,
0.003349306294694543,
-0.03848831355571747,
-0.04434991627931595,
0.053810857236385345,
-0.02800041437149048,
-0.01606452278792858,
0.018605755642056465,
0.037214066833257675,
-0.016928281635046005,
0.009158673696219921,
0.04821707680821419,
-0.05129406601190567,
-0.025... | 0.810413 | 0.761637 | 0.048776 |
You are tasked with creating a function that consumes a tree and returns the sum of all the elements in the tree. The tree is defined as follows:
```ocaml
type 'a tree =
| Leaf
| Node of 'a tree * 'a * 'a tree
```
You need to implement a function that takes a tree and returns the sum of all the elements in the tree. ... | glaive | [
0.013645733706653118,
0.02720664069056511,
-0.03363858163356781,
-0.06038730591535568,
0.03981740400195122,
-0.04017287865281105,
0.016220124438405037,
0.0690833032131195,
0.029689501971006393,
-0.004134062211960554,
0.028488537296652794,
0.044741809368133545,
-0.03358461335301399,
0.00065... | 0.804274 | 0.783265 | 0.021008 |
You are tasked with implementing a nearest neighbor upsampling kernel for a CUDA-based application. The goal is to create a symmetrical implementation where kernels write data to destination tensors, each thread reads data from the source tensor, and scale factors are used to determine the mapping from input tensors to... | glaive | [
0.0011070409091189504,
0.046502284705638885,
-0.0034356999676674604,
-0.012990827672183514,
0.028203386813402176,
0.004094209522008896,
-0.015714554116129875,
0.08249238133430481,
0.03830830752849579,
-0.018271194770932198,
0.028840158134698868,
0.033262211829423904,
-0.01888466812670231,
... | 0.800603 | 0.784068 | 0.016535 |
You have been tasked with implementing a function in Python that takes in a list of integers and returns the maximum value in the list. The function should be named "find_max_value" and should take in one parameter: a list of integers. You are not allowed to use any built-in Python functions to find the maximum value (... | glaive | [
0.035677824169397354,
0.034244365990161896,
-0.032727546989917755,
-0.04015322029590607,
0.041793376207351685,
-0.03095470368862152,
-0.019409554079174995,
0.026913758367300034,
0.02849642001092434,
-0.016834860667586327,
0.022743728011846542,
0.0498494915664196,
-0.02066827565431595,
0.00... | 0.811831 | 0.774088 | 0.037743 |
I need to create a CUDA program that adds two arrays of floating-point numbers element-wise. The program should utilize the CUDA framework and specifically use the provided CudaFlow class. The Add method in the CudaFlow class takes in two arrays of float values (op1 and op2), the number of elements in the arrays (count... | glaive | [
-0.006291192956268787,
0.04709217697381973,
-0.01240706630051136,
-0.015330699272453785,
0.039067402482032776,
-0.00849862676113844,
-0.019570188596844673,
0.10012167692184448,
0.045675382018089294,
-0.015471426770091057,
0.02072211168706417,
0.035478375852108,
-0.01199007872492075,
-0.006... | 0.791402 | 0.776742 | 0.01466 |
I have an array of unique elements. How can I convert this array into an unfolded matrix using an algorithm? | glaive | [
0.02195098251104355,
0.02992652915418148,
-0.01141109224408865,
-0.029992947354912758,
0.04163956269621849,
-0.03652781993150711,
-0.014710161834955215,
0.06372465938329697,
0.029332010075449944,
-0.027349088340997696,
0.016216004267334938,
0.006711362395435572,
-0.02893323265016079,
-0.03... | 0.794081 | 0.77262 | 0.021461 |
You are tasked with implementing a CUDA kernel function called submean_kernel that subtracts the mean value from each element of a source array and stores the result in a destination array. The kernel function takes in the following parameters:
- src: Pointer to the source array of type Ts
- dst: Pointer to the destina... | glaive | [
-0.019800221547484398,
0.06009684503078461,
-0.03613022342324257,
-0.036582428961992264,
0.04697060212492943,
-0.01716599054634571,
-0.04040224105119705,
0.08270291239023209,
0.0605640672147274,
-0.003118466818705201,
0.03209371864795685,
0.028392676264047623,
-0.022480111569166183,
0.0171... | 0.801171 | 0.778256 | 0.022915 |
You are tasked with creating a program that will parse a given string to extract specific commands and their corresponding arguments. The commands and arguments are represented by specific patterns within the string. The commands are represented by uppercase letters (e.g. D, S, W, A) and the arguments are represented b... | glaive | [
0.03389842063188553,
0.022756414487957954,
-0.034217026084661484,
-0.039556026458740234,
0.023349063470959663,
-0.03217874839901924,
-0.017131565138697624,
0.040626149624586105,
0.03582580387592316,
-0.017319750040769577,
0.03222105652093887,
0.05001160874962807,
-0.029064830392599106,
-0.... | 0.830665 | 0.797364 | 0.033301 |
You are tasked with creating a CUDA kernel function that doubles the values of a 2D array. The input to the kernel function will be a 1D array representing a 4x4 2D array. The kernel function should calculate the index of each element in the 2D array using the formula idx = threadIdx.x + threadIdx.y*4 and then double t... | glaive | [
0.009564188309013844,
0.054866377264261246,
-0.02151360921561718,
-0.013949759304523468,
0.036307282745838165,
-0.0170650165528059,
-0.03371280059218407,
0.08749131113290787,
0.037166837602853775,
-0.004474160261452198,
0.028321074321866035,
0.03492540121078491,
-0.023532124236226082,
-0.0... | 0.802147 | 0.781969 | 0.020178 |
You are tasked with creating a Python program that will calculate the area of a rectangle. The program should prompt the user to input the length and width of the rectangle, and then calculate and display the area of the rectangle. | glaive | [
0.006702985614538193,
0.054852526634931564,
-0.04417404532432556,
-0.03842802718281746,
0.017517855390906334,
-0.01996021904051304,
-0.024634037166833878,
0.04070884361863136,
0.046989280730485916,
-0.006662097293883562,
0.02476818859577179,
0.051098939031362534,
-0.027695415541529655,
-0.... | 0.776233 | 0.756175 | 0.020058 |
You are tasked with implementing the ROIPool operation for a neural network on a CUDA-enabled device. The ROIPool operation takes as input a feature map (x) of shape (N, C, H, W), a set of region of interests (rois) of shape (num_rois, 5), and outputs a pooled feature map (y) of shape (num_rois, C, pool_h, pool_w). The... | glaive | [
0.020507119596004486,
0.023947814479470253,
-0.015728505328297615,
-0.011945096775889397,
0.0119455736130476,
-0.023599160835146904,
-0.023034710437059402,
0.07813955843448639,
0.04906832426786423,
-0.019877690821886063,
0.045454882085323334,
0.026077555492520332,
-0.01695369742810726,
-0.... | 0.802933 | 0.786646 | 0.016287 |
You are working with Nim programming language and want to create a function that takes in a list of integers and returns the sum of all the numbers in the list. Write a function called `sumOfList` that takes a list of integers as input and returns the sum of all the numbers in the list. | glaive | [
0.008031853474676609,
0.00842262152582407,
-0.035689327865839005,
-0.04060720279812813,
0.07011604309082031,
-0.03733823820948601,
-0.017074566334486008,
0.039229974150657654,
0.03811868652701378,
0.0019216276705265045,
0.02286459691822529,
0.053033918142318726,
-0.045327045023441315,
-0.0... | 0.800544 | 0.786221 | 0.014323 |
You are required to write a CUDA C++ program that unpacks a series of complex floating-point time series data. The data is stored in memory as an array of float2 elements, where each float2 contains the real and imaginary parts of a single complex number. The unpacking process involves copying and reordering the data f... | glaive | [
0.008852004073560238,
0.04038510099053383,
-0.015324516221880913,
-0.03481109067797661,
0.02925138734281063,
-0.023400306701660156,
-0.024996155872941017,
0.10289177298545837,
0.04996563121676445,
0.006625864189118147,
0.03161952644586563,
0.03635504096746445,
-0.0077142477966845036,
0.010... | 0.797477 | 0.778345 | 0.019133 |
How can I write an algorithm that calculates the maximum sum of any path through a given matrix? | glaive | [
0.013495620340108871,
0.012103610672056675,
-0.02554793655872345,
-0.0338924303650856,
0.03093959018588066,
-0.030066946521401405,
-0.027738383039832115,
0.031620901077985764,
0.01780189760029316,
-0.0371207520365715,
0.02585808001458645,
0.035250768065452576,
-0.01823713257908821,
-0.0227... | 0.800612 | 0.776241 | 0.024371 |
You are tasked with creating 6502 assembly routines for multiplication, division, and modulus operations, as well as a string constant accessor.
For multiplication, you need to implement:
- A routine to multiply a given 8-bit value (XA) by an immediate 8-bit value.
- A routine to multiply XA by a 16-bit value stored a... | glaive | [
0.04280247539281845,
0.03197972849011421,
-0.017594706267118454,
-0.01541796326637268,
0.02965332381427288,
-0.056150153279304504,
-0.024411769583821297,
0.0661066323518753,
0.024984821677207947,
-0.009861093945801258,
0.02927548997104168,
0.02437424287199974,
-0.010439283214509487,
-0.011... | 0.798632 | 0.780459 | 0.018173 |
You are tasked with creating a program that simulates a genetic algorithm for a specific problem. The simulation requires the use of template macros and specific parameters for the genetic algorithm. The genetic algorithm will involve a certain number of genomes, generations, tile types, edge types, byte length of the ... | glaive | [
0.010542890056967735,
0.00100394815672189,
-0.011747930198907852,
-0.03282708302140236,
0.03308052197098732,
-0.032735466957092285,
-0.05815612152218819,
0.10481831431388855,
0.01200473215430975,
-0.025982214137911797,
0.017656425014138222,
0.04799094796180725,
-0.01810360699892044,
0.0139... | 0.792117 | 0.76321 | 0.028907 |
You have been tasked with creating a program to calculate the probability amplitudes for a quantum system with a given number of qubits and states. The program should then find the maximum probability of a specific state and generate a 3D plot to visualize the probability distribution.
Write a program that takes the n... | glaive | [
0.00993806216865778,
0.027762649580836296,
-0.025586791336536407,
-0.021314317360520363,
0.03807331249117851,
-0.035020191222429276,
-0.022002670913934708,
0.06798616796731949,
0.03290388360619545,
0.0018018865957856178,
0.02152734249830246,
0.03488073870539665,
-0.02075638808310032,
-0.01... | 0.792112 | 0.758097 | 0.034015 |
What is a possible solution to generate all possible permutations of an array of integers in a computer program? | glaive | [
0.01374103594571352,
0.026672210544347763,
-0.02264092117547989,
-0.01902787573635578,
0.036777906119823456,
-0.03303392231464386,
-0.021569177508354187,
0.06006307154893875,
0.04640938714146614,
-0.05374223366379738,
0.022360794246196747,
0.033802639693021774,
-0.02558840624988079,
-0.023... | 0.804836 | 0.783464 | 0.021372 |
I am trying to create a program that calculates the difference of squares. The program should have three functions:
1. `squareOfSum` which calculates the square of the sum of the numbers up to the given number.
2. `sumOfSquares` which calculates the sum of the squares of the numbers up to the given number.
3. `differen... | glaive | [
0.013568609952926636,
0.030870942398905754,
-0.04271237179636955,
-0.05607031658291817,
0.05594668537378311,
-0.015898527577519417,
-0.016491053625941277,
0.06005384773015976,
0.05256321281194687,
-0.02654259093105793,
0.03166961669921875,
0.03464515879750252,
-0.05606025084853172,
-0.0230... | 0.816676 | 0.800706 | 0.015971 |
I'm trying to find an efficient algorithm to find the maximum sum of a continuous subarray from a given array. Can you provide a solution for this? | glaive | [
0.0036292513832449913,
0.028939947485923767,
-0.03428007662296295,
-0.024512391537427902,
0.03257724642753601,
-0.031252890825271606,
-0.02827070839703083,
0.04047853872179985,
0.04067134112119675,
-0.02903056889772415,
0.032522350549697876,
0.017293954268097878,
-0.04583233594894409,
-0.0... | 0.804532 | 0.782055 | 0.022477 |
You are tasked with implementing a CUDA-C program to solve the SGBM (Semi-Global Block Matching) algorithm for stereo vision. The problem involves three distinct kernels: cost_computation, compute_hamming, and cost_aggregation. These kernels will be responsible for computing the cost, aggregating the cost, and performi... | glaive | [
0.003019573399797082,
0.032451629638671875,
-0.026891494169831276,
-0.018267488107085228,
0.028453120961785316,
-0.0001599716633791104,
-0.03737204894423485,
0.09091342985630035,
0.04766135290265083,
-0.022722696885466576,
0.026812953874468803,
0.02720564790070057,
0.00853935070335865,
-0.... | 0.804425 | 0.781301 | 0.023124 |
You are required to write a function in x86 Assembly Language using NASM syntax for the Linux 32-bit architecture. The function, named cvt_string2int, takes two parameters: addr_instring (the address of a string) and instrlen (the length of the string). It should return the integer value derived from the input string. ... | glaive | [
0.010124769993126392,
0.04175645858049393,
-0.011503993533551693,
-0.016788126900792122,
0.03369690850377083,
-0.042706143110990524,
-0.03519993647933006,
0.0663890391588211,
0.029427526518702507,
-0.006579573731869459,
0.04847099632024765,
0.025504447519779205,
-0.028408117592334747,
-0.0... | 0.796737 | 0.778833 | 0.017904 |
I need help designing a Java program that takes in an array with ten elements and prints out the elements in the order of their odd and even numbers. Can you provide a solution for this?
For example, given the array [10, 3, 5, 2, 9, 6, 8, 1, 4, 7], the output should be:
Even Numbers:
10
2
6
8
4
Odd Numbers:
3
5
9
1
... | glaive | [
0.02582511119544506,
0.02532791905105114,
-0.04209248349070549,
-0.03392967954277992,
0.017414281144738197,
-0.04747077450156212,
-0.035782452672719955,
0.04502047970890999,
0.03052646480500698,
-0.03625932335853577,
0.01849980652332306,
0.013039596378803253,
-0.056425776332616806,
-0.0190... | 0.807882 | 0.777306 | 0.030577 |
You are tasked with creating a game simulation program that plays multiple games and tracks the statistics of each game played. The game simulation program must play a specified number of games and keep track of the establishments owned by the winner, as well as the coins earned by all players and by the winner for eac... | glaive | [
0.02047077566385269,
0.007621405646204948,
-0.03939037024974823,
-0.04161814972758293,
0.0352153554558754,
-0.01820647343993187,
-0.034581258893013,
0.042534418404102325,
0.035925399512052536,
-0.03278425335884094,
0.03231130912899971,
0.0362684428691864,
-0.03346934914588928,
0.0025936530... | 0.793565 | 0.771431 | 0.022134 |
You are tasked with creating a program that calculates the area of a circle. The program should take the radius of the circle as input and output the area. You must use Python for this task. | glaive | [
-0.008663887158036232,
0.05435571447014809,
-0.03504050895571709,
-0.0249477531760931,
0.026829224079847336,
-0.01498603355139494,
-0.030161766335368156,
0.02974986471235752,
0.036230579018592834,
-0.009134234860539436,
0.021870428696274757,
0.04024524241685867,
-0.02614080160856247,
-0.01... | 0.768914 | 0.740841 | 0.028072 |
You are tasked with implementing a function to replace a specific value with a new value in a non-empty sequence. The function should take in three parameters: the old value, the new value, and the non-empty sequence.
Write a function called `replace` that takes in the old value, the new value, and the non-empty seque... | glaive | [
0.023455286398530006,
0.04284599795937538,
-0.011195807717740536,
-0.03604147210717201,
0.03470183163881302,
-0.03288764879107475,
-0.024962125346064568,
0.06450151652097702,
0.03823811933398247,
-0.030917003750801086,
0.028066523373126984,
0.005411198362708092,
-0.03389037400484085,
0.001... | 0.802626 | 0.784496 | 0.01813 |
You are tasked with writing a program to perform complex number multiplication. You are given three complex numbers q, e, and d defined as follows:
q = 11 - 5i
e = 11 + 5i
d = 2i
Write a program to calculate the product of q, e, and d and output the result in the form of a complex number in the format a + bi, where a a... | glaive | [
0.03560202941298485,
0.027766451239585876,
-0.03659111261367798,
-0.053549278527498245,
0.046977441757917404,
-0.022635212168097496,
-0.0035147839225828648,
0.06461994349956512,
0.04587966203689575,
-0.00721905380487442,
0.02173668146133423,
0.04790649935603142,
-0.06198325753211975,
-0.04... | 0.80934 | 0.786027 | 0.023313 |
You are tasked with implementing a binary search lower-bound partitioning algorithm in CUDA. The goal is to fill an array of partition indices based on a given prefix sum array and a number of partitions. The algorithm should be designed to run efficiently on a GPU, taking advantage of CUDA parallelism and shared memor... | glaive | [
-0.004733683541417122,
0.03792649134993553,
-0.02727394923567772,
-0.006261431612074375,
0.023508988320827484,
-0.004148449283093214,
-0.017092401161789894,
0.07946107536554337,
0.045357782393693924,
-0.01849634200334549,
0.013608536683022976,
0.0265626460313797,
0.0021868599578738213,
0.0... | 0.816582 | 0.784372 | 0.03221 |
You are tasked with creating a program that calculates the eigenvalues and eigenvectors of a 2x2 symmetric matrix. You will need to use the cucheb library and the 2x2symeig function. The function takes 7 parameters: the elements of the 2x2 matrix, a tolerance value, and pointers to the variables for the eigenvalues and... | glaive | [
0.027233794331550598,
0.03596577048301697,
-0.03640935942530632,
-0.037633877247571945,
0.033885013312101364,
-0.02019476890563965,
-0.018592627719044685,
0.07162322103977203,
0.04082554951310158,
-0.026677504181861877,
0.0034570908173918724,
0.036103032529354095,
-0.037748340517282486,
-0... | 0.799999 | 0.773815 | 0.026184 |
You are tasked with implementing a random engine using the Linear Congruential Generator (LCG) algorithm. The engine should have a 48-bit internal state and produce 32 bits of output per invocation. The algorithm for the LCG is as follows:
Xn+1 = (a * Xn + c) mod m
Where:
- Xn is the current state
- Xn+1 is the next st... | glaive | [
0.013845053501427174,
0.02290136180818081,
-0.009782266803085804,
-0.04801510274410248,
0.032780274748802185,
-0.03034822829067707,
-0.04605085402727127,
0.057283200323581696,
0.011931986548006535,
-0.025752929970622063,
0.031477637588977814,
0.02458082139492035,
-0.02733401395380497,
-0.0... | 0.811997 | 0.784738 | 0.027258 |
You are tasked with implementing a function in the Stan programming language that calculates the stationary covariance matrix of a given transition matrix T and the square root of the covariance matrix RQR. The function signature should be:
```stan
matrix stationary_cov(matrix T, matrix RQR)
```
The function should tak... | glaive | [
0.04977119714021683,
0.036733537912368774,
-0.05487184599041939,
-0.04712257534265518,
0.05099116638302803,
-0.01218481082469225,
-0.018948277458548546,
0.09426330029964447,
0.030928922817111015,
-0.007915842346847057,
0.007304443046450615,
0.028652768582105637,
-0.034098394215106964,
0.00... | 0.798351 | 0.777593 | 0.020758 |
I am conducting a study on the space complexity of the bubble sort algorithm. I know that the space complexity of the bubble sort algorithm is O(1). Given the below bubble sort algorithm, how can I modify the code to achieve a space complexity of O(n) or O(n^2)? I would like to understand how the space complexity affec... | glaive | [
-0.01347471121698618,
0.039641737937927246,
-0.02540448121726513,
-0.027347426861524582,
0.010838137939572334,
-0.032739121466875076,
-0.025698600336909294,
0.07192273437976837,
0.010703276842832565,
-0.0158022940158844,
0.001925924327224493,
0.00842916127294302,
-0.023691337555646896,
-0.... | 0.811468 | 0.782932 | 0.028536 |
You are tasked with implementing a function that calculates the elementwise maximum (max) of two input arrays. The function should take two input arrays and return an output array where each element is the maximum of the corresponding elements from the input arrays.
Your task is to implement the `max` function with th... | glaive | [
0.04034543037414551,
0.03038696013391018,
-0.025671109557151794,
-0.03372707590460777,
0.022637415677309036,
-0.026821507140994072,
-0.01998049020767212,
0.07130352407693863,
0.02512327954173088,
-0.004527650307863951,
0.03345153480768204,
0.03699250891804695,
-0.013622899539768696,
-0.014... | 0.816136 | 0.795491 | 0.020645 |
Can an AI help me create a Python subroutine that checks if a specific whole number exists within a one-dimensional array of discrete numerical values?
Here is the provided list and integral value:
arr = [1, 2, 3, 4]
x = 2 | glaive | [
0.021823905408382416,
0.037628479301929474,
-0.03118054009974003,
-0.026801470667123795,
0.0375739187002182,
-0.027058567851781845,
-0.013208105228841305,
0.052670132368803024,
0.027961064130067825,
-0.02268371172249317,
0.017595520243048668,
0.02706422097980976,
-0.01119612343609333,
-0.0... | 0.83078 | 0.808645 | 0.022135 |
You are tasked with creating a function in Racket that takes a list of numbers as input and returns a new list containing only the even numbers from the original list. The function should be named "filter-even" and should take a single parameter "lst" representing the input list of numbers.
Write a function filter-eve... | glaive | [
0.03276496008038521,
0.026770438998937607,
-0.021291011944413185,
-0.04570423811674118,
0.03932596743106842,
-0.013615765608847141,
-0.012505627237260342,
0.05084687098860741,
0.03579994663596153,
-0.01576397754251957,
0.004969335626810789,
0.052463971078395844,
-0.029762672260403633,
-0.0... | 0.802778 | 0.772374 | 0.030403 |
You are tasked with creating a program to calculate the probability amplitudes of a quantum system and visualize the results. The program should define a function to calculate the probability amplitude for a given set of variables, and then use this function to find the maximum probability amplitude for a specific rang... | glaive | [
0.005743584129959345,
0.028117932379245758,
-0.032855283468961716,
-0.02528487890958786,
0.04229152575135231,
-0.041845183819532394,
-0.027024898678064346,
0.06371404230594635,
0.039660677313804626,
0.0010475297458469868,
0.01775216870009899,
0.04031059518456459,
-0.01953842304646969,
-0.0... | 0.795702 | 0.7743 | 0.021402 |
You are tasked with creating a generic iterator in Common Lisp that can iterate through a list or a vector. The iterator should be able to determine if it has reached the end of the list or vector, and be able to move to the next element.
Write a class `iterator` with the following generic functions:
- `iterator-end-p... | glaive | [
0.02636558935046196,
0.04513774812221527,
-0.0013711064821109176,
-0.06012796238064766,
0.05012772977352142,
-0.05113910883665085,
-0.03211414813995361,
0.06561789661645889,
0.036612618714571,
-0.026340732350945473,
0.04252757504582405,
0.0481557622551918,
-0.029414843767881393,
-0.0084626... | 0.802985 | 0.787231 | 0.015755 |
You are tasked with writing a program to calculate the number of n X 6 arrays with the following properties:
- The rows are unimodal (i.e., the elements in each row are in increasing order up to a certain point, after which they are in decreasing order).
- The columns are non-decreasing (i.e., the elements in each colu... | glaive | [
0.013948537409305573,
0.03330396115779877,
-0.04078664630651474,
-0.005928675644099712,
0.03860558569431305,
-0.0231382567435503,
-0.047620754688978195,
0.05788930878043175,
0.019972732290625572,
-0.012601864524185658,
0.011797071434557438,
0.033144500106573105,
-0.0407310351729393,
-0.033... | 0.831401 | 0.769633 | 0.061767 |
You are tasked with implementing a function to extract radix values from a given string set. The function should take into account various parameters and should be able to handle different word sizes.
Specifically, you need to implement the following:
- A function to pack a set of head flags into a bit-packed array.
-... | glaive | [
0.0345197394490242,
0.04129810258746147,
-0.02968485839664936,
-0.029084669426083565,
0.029537258669734,
-0.05780136585235596,
-0.009559111669659615,
0.07047268748283386,
0.04809579625725746,
-0.01639203540980816,
0.02454438991844654,
0.01289227046072483,
-0.03365021198987961,
-0.013675075... | 0.818335 | 0.802497 | 0.015838 |
You are tasked with creating a program that can perform basic arithmetic operations and handle exponentiation. The program should take input in the form of mathematical expressions and produce the correct output. The input will consist of numbers, operators (+, -, *, /, ^), and parentheses. Your program should be able ... | glaive | [
0.05271410942077637,
0.027538394555449486,
-0.015738816931843758,
-0.03377345949411392,
0.042332690209150314,
-0.035287030041217804,
-0.013086199760437012,
0.07020848244428635,
0.04375487193465233,
-0.02873467095196247,
0.0159248448908329,
0.026496151462197304,
-0.030042311176657677,
-0.02... | 0.795003 | 0.769315 | 0.025688 |
You are tasked with implementing a parallel sorting algorithm using CUDA in C++. Given an array of floating-point numbers and its length, your goal is to write a CUDA kernel that sorts the array using the odd-even sort algorithm. The odd-even sort algorithm is a simple parallel sorting algorithm that works by performin... | glaive | [
0.007302281446754932,
0.03497319296002388,
-0.00993250496685505,
-0.02065562643110752,
0.018689293414354324,
0.009131792932748795,
-0.037400294095277786,
0.10210661590099335,
0.042622294276952744,
-0.016902262344956398,
0.015729736536741257,
0.03126272186636925,
-0.0021435571834445,
0.0068... | 0.808094 | 0.773059 | 0.035035 |
I need to design a high-efficiency search routine in C++ to find a specific whole number within a large scale and randomized set of numbers. The set I'm working with is [93, 7, 65, 100, 31, 2, 48, 75, 53, 200]. Can someone help me with an efficient solution? | glaive | [
0.019950876012444496,
0.029388321563601494,
-0.0477001890540123,
-0.019353555515408516,
0.02671874314546585,
-0.02573641575872898,
-0.022054404020309448,
0.06628940254449844,
0.03853874281048775,
-0.03393949195742607,
0.022863825783133507,
0.031391870230436325,
-0.03369104489684105,
-0.003... | 0.816529 | 0.795003 | 0.021526 |
You are given an array of integers called "numbers". Your task is to find two numbers in the array that add up to 2020, and then multiply those two numbers to get the final result. If no such pair exists, you should print a message indicating that no match was found. Additionally, you need to find three numbers in the ... | glaive | [
0.03060980513691902,
0.03642037883400917,
-0.05163908749818802,
-0.03273138776421547,
0.040348488837480545,
-0.014899114146828651,
-0.032470591366291046,
0.056238073855638504,
0.026167502626776695,
-0.01161080040037632,
0.012404114007949829,
0.03454897180199623,
-0.0366223081946373,
-0.015... | 0.828349 | 0.794377 | 0.033972 |
You are tasked with implementing a function that removes duplicates from an unordered list without using the Data.List function `nub`. The function should take in a list of elements and return a new list with all duplicate elements removed. You are only allowed to use the `removeElement` function provided, and you shou... | glaive | [
0.0037055821157991886,
0.02230849117040634,
-0.02045641466975212,
-0.04450221359729767,
0.03791019320487976,
-0.031292058527469635,
0.0006541571929119527,
0.07133063673973083,
0.046672843396663666,
-0.016885653138160706,
0.00614228006452322,
0.0003494834527373314,
0.002438030671328306,
-0.... | 0.805942 | 0.786647 | 0.019295 |
You are tasked with implementing a 2D image convolution operation in C. Image convolution is a fundamental operation in image processing that involves applying a mask to an image to perform various transformations. The goal is to write a program that takes an input image and a mask, performs the convolution operation, ... | glaive | [
0.007274820003658533,
0.0504189059138298,
-0.013012876734137535,
-0.015395074151456356,
0.02569926716387272,
-0.0006908240611664951,
-0.03818820044398308,
0.10354238748550415,
0.03835153207182884,
-0.013225832022726536,
0.02036149427294731,
0.0048898071981966496,
-0.023063667118549347,
-0.... | 0.785583 | 0.756933 | 0.028649 |
You are tasked with using CUDA to implement a program that counts the number of prime numbers within a certain range. The program should utilize parallel processing to efficiently calculate the prime numbers and provide accurate results.
Create a CUDA program that includes a kernel function to calculate the prime numb... | glaive | [
0.01000257022678852,
0.045781102031469345,
-0.01600499637424946,
-0.01535419188439846,
0.02471664734184742,
-0.006162043660879135,
-0.015616454184055328,
0.09757006913423538,
0.03534262627363205,
-0.02337629534304142,
0.014251047745347023,
0.0374874621629715,
-0.004227877594530582,
-0.0010... | 0.813602 | 0.78636 | 0.027242 |
You are working on a project that requires you to create a function to determine if a given set of real numbers is compact. You need to implement a function that checks if a closed interval [a, b] is compact.
Write a function that takes two real numbers a and b as input, and returns true if the closed interval [a, b]... | glaive | [
0.022062553092837334,
0.031231064349412918,
-0.04033396765589714,
-0.010416990146040916,
0.048884157091379166,
-0.017698269337415695,
-0.005799311678856611,
0.06873558461666107,
0.04194338247179985,
-0.005701950751245022,
0.01954754814505577,
0.030714089050889015,
-0.016739005222916603,
-0... | 0.805766 | 0.790664 | 0.015102 |
You are tasked with creating a function in Lua that calculates 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 (written as 5!) is 5 * 4 * 3 * 2 * 1 = 120. Your function should take a single parame... | glaive | [
0.021118443459272385,
0.03749002888798714,
-0.029733989387750626,
-0.04650444909930229,
0.0512985996901989,
-0.021833229809999466,
-0.02194087952375412,
0.044840626418590546,
0.036594778299331665,
-0.014213668182492256,
0.0159883052110672,
0.04298214241862297,
-0.04714026674628258,
-0.0292... | 0.795996 | 0.769413 | 0.026583 |
You are tasked with implementing a program that defines a data partitioning structure in a specific programming language. The structure should include the specification of how a single logical data stream is partitioned, leaving out the parameters that determine the physical partitioning. The program should include the... | glaive | [
0.030470848083496094,
0.004485026933252811,
-0.03837361931800842,
-0.0020560636185109615,
0.025524120777845383,
-0.023449882864952087,
-0.00595429539680481,
0.08932360261678696,
0.03686769679188728,
-0.022273067384958267,
0.030906349420547485,
0.04638085514307022,
-0.03436838090419769,
0.0... | 0.809289 | 0.789257 | 0.020032 |
You are tasked with creating a program that simulates a robot navigating through a grid of locations. The robot can move forward or backward between adjacent locations and sense its surroundings to determine if certain paths are passable or not.
Your task is to implement a program that takes the initial and goal loca... | glaive | [
0.008708694949746132,
0.02205151692032814,
-0.013671619817614555,
-0.029111947864294052,
0.02972385473549366,
-0.029617544263601303,
-0.030927853658795357,
0.06051748991012573,
0.03775521740317345,
-0.026009611785411835,
0.036975838243961334,
0.043384578078985214,
-0.035095132887363434,
-0... | 0.805382 | 0.787598 | 0.017784 |
You are tasked with simulating the process of hiring the best secretary out of a pool of candidates. You are given a set of N candidates, each with a distinct rank. The goal is to hire the best secretary, which means choosing the candidate with the highest rank without interviewing all the candidates. You need to creat... | glaive | [
-0.0024616431910544634,
0.012932110577821732,
-0.047337934374809265,
-0.022848742082715034,
0.03980210795998573,
-0.025862259790301323,
-0.03714415431022644,
0.04826006293296814,
0.0498645044863224,
-0.00935873668640852,
0.021670620888471603,
0.031910691410303116,
-0.008876655250787735,
0.... | 0.820921 | 0.798981 | 0.02194 |
You are tasked with creating a function in Lean that computes the sum of two natural numbers n and m and returns the result. The function signature should be as follows:
```lean
def sum_of_natural_numbers (n m : ℕ) : ℕ := -- your implementation here
```
You need to implement the logic for adding two natural numbers and... | glaive | [
0.013530299067497253,
0.017614904791116714,
-0.043600182980298996,
-0.061591070145368576,
0.045995377004146576,
-0.0035455096513032913,
-0.02961854264140129,
0.04136326164007187,
0.029341433197259903,
-0.005678273271769285,
0.020282698795199394,
0.04119892418384552,
-0.031177621334791183,
... | 0.814253 | 0.796077 | 0.018176 |
I need to write a Clojure function that calculates the floor level based on a given input string. The input string consists of open and closed parentheses, where an open parenthesis "(" represents going up one floor, and a closed parenthesis ")" represents going down one floor. The function should return the final floo... | glaive | [
0.010218295268714428,
0.03358324244618416,
-0.029797565191984177,
-0.048287905752658844,
0.04605558142066002,
-0.03425535187125206,
-0.0012089796364307404,
0.03841822221875191,
0.04235757887363434,
-0.0033707215916365385,
0.02951643243432045,
0.042566124349832535,
-0.040597446262836456,
-0... | 0.807211 | 0.786292 | 0.020919 |
You are tasked with implementing a multi-search algorithm using the CTA+warp approach in CUDA. The goal is to find the shortest paths from a given source vertex to all other vertices in a graph. The provided code snippet includes a CUDA kernel function multi_search_CTA_warp_based, which performs the actual search using... | glaive | [
0.011883384548127651,
0.04944908991456032,
-0.02539198100566864,
0.006449955981224775,
0.030030781403183937,
-0.008611384779214859,
-0.043487001210451126,
0.08218558132648468,
0.044080931693315506,
-0.03278668597340584,
0.029197027906775475,
0.032501041889190674,
0.008765454404056072,
0.00... | 0.81047 | 0.786007 | 0.024463 |
You are tasked with creating a set of procedures to manipulate bitvectors in Scheme. Bitvectors are fixed-size sequences of bits, and you need to implement various operations to create, copy, reverse, concatenate, fold, map, iterate, and convert bitvectors. Your goal is to create efficient and precise procedures that w... | glaive | [
0.0400523915886879,
0.024864641949534416,
-0.012590247206389904,
-0.009791535325348377,
0.048896923661231995,
-0.03877311199903488,
-0.015540462918579578,
0.059585683047771454,
0.053353019058704376,
-0.004521567840129137,
0.02051052451133728,
0.04809167608618736,
-0.03174459561705589,
0.00... | 0.802195 | 0.786325 | 0.01587 |
You are tasked with creating a program that can sort a given list of numbers in ascending order. The program should take a list of integers as input and return the sorted list as output. You are not allowed to use any built-in sorting functions or libraries in your solution. | glaive | [
0.042896587401628494,
0.02221018634736538,
-0.02771800383925438,
-0.024079477414488792,
0.023691410198807716,
-0.01779228448867798,
-0.011982505209743977,
0.04535941407084465,
0.03124142996966839,
-0.030779298394918442,
0.01936568133533001,
0.03473205119371414,
-0.041901372373104095,
-0.00... | 0.82099 | 0.783634 | 0.037356 |
You are tasked with implementing a Bayesian hierarchical model using the Stan programming language. The model aims to predict the relationship between a set of predictor variables and a response variable, given data from multiple counties. The data includes the number of counties (J), the total number of observations (... | glaive | [
0.01615900546312332,
0.016879718750715256,
-0.03379727154970169,
-0.05118757486343384,
0.03542608395218849,
-0.017132258042693138,
-0.015526610426604748,
0.07939255982637405,
0.04520407319068909,
-0.015103353187441826,
0.001987382071092725,
0.049153417348861694,
-0.018069064244627953,
0.01... | 0.792097 | 0.777658 | 0.014439 |
You are tasked with creating a program that counts the number of variables in a specified varlist that have values matching the items provided in the numval() and strval() options. The program should also create a new variable with the count of matching variables. | glaive | [
0.0015111500397324562,
0.01763133518397808,
-0.049994468688964844,
-0.016849149018526077,
0.05389698967337608,
-0.02610199712216854,
-0.019149621948599815,
0.055226463824510574,
0.028398260474205017,
-0.00552937388420105,
0.008544002659618855,
0.049378979951143265,
-0.019185731187462807,
-... | 0.812822 | 0.793758 | 0.019064 |
You are tasked with implementing a function that takes in a list of strings and concatenates them into a single string. The function should efficiently handle the concatenation of the strings to ensure optimal performance.
Write a function called `efficient-string-concatenation` that takes in a list of strings as inpu... | glaive | [
0.02048427052795887,
0.051870401948690414,
0.010547971352934837,
-0.040242649614810944,
0.04318827763199806,
-0.04677772894501686,
-0.028049645945429802,
0.03359787538647652,
0.047477588057518005,
-0.012180683203041553,
0.006448756437748671,
0.046476516872644424,
-0.028962669894099236,
-0.... | 0.792523 | 0.775951 | 0.016572 |
Write a C++ program that performs a recursive filter operation on a set of input data. The program should be able to handle a large number of iterations and a large number of input samples. The input data should be divided into batches for parallel processing. The code should be able to run on a GPU and should check th... | glaive | [
0.009643415920436382,
0.04308175668120384,
-0.013267542235553265,
-0.026954151690006256,
0.029719723388552666,
0.0014558462426066399,
-0.0254006739705801,
0.11343399435281754,
0.03439163416624069,
-0.030589589849114418,
0.01723496988415718,
0.02674187533557415,
-0.005840491037815809,
-0.00... | 0.796246 | 0.772938 | 0.023308 |
You are tasked with implementing a PinHoleCamera class in C++ to model a pinhole camera for a graphics application. The PinHoleCamera class should inherit from the Camera class and implement the necessary functionality to represent a pinhole camera, including the calculation of the current ray and post-processing of th... | glaive | [
0.014101650565862656,
0.03266458585858345,
0.0028388481587171555,
-0.03807364031672478,
0.044139962643384933,
0.011481226421892643,
-0.035154007375240326,
0.11123026907444,
0.034430135041475296,
-0.020681362599134445,
0.027989959344267845,
0.06291932612657547,
-0.01753189042210579,
-0.0190... | 0.783108 | 0.768713 | 0.014396 |
You are tasked with implementing CUDA kernels for sorting, computing, and rearranging data for a scientific computation project. The kernels will be used for numerical calculations and data manipulation on a GPU.
Your task is to implement the following CUDA kernels:
1. sortMKernel: A kernel that takes an input matrix ... | glaive | [
0.016864163801074028,
0.042192939668893814,
-0.013384584337472916,
-0.018030893057584763,
0.026673080399632454,
-0.0013833530247211456,
-0.0185006782412529,
0.08492382615804672,
0.04709191992878914,
-0.004576446488499641,
0.02452823519706726,
0.02540484629571438,
-0.008064894936978817,
0.0... | 0.796704 | 0.782189 | 0.014515 |
You are required to write a CUDA kernel that performs computations on arrays using the given code snippet as a reference. The kernel should take input arrays Ac_arr, Ap_arr, Dinv_arr, and RHS_arr, and compute the output array out_arr based on the provided algorithm. The arrays are 3D and have dimensions STRIDE x STRIDE... | glaive | [
0.016182413324713707,
0.06896080076694489,
-0.008840527385473251,
-0.007960952818393707,
0.04121930152177811,
-0.01798500120639801,
-0.039869360625743866,
0.0879133865237236,
0.03462954983115196,
-0.01610102690756321,
0.02487052045762539,
0.038085274398326874,
-0.023445837199687958,
-0.017... | 0.800243 | 0.771409 | 0.028835 |
Can you provide an algorithm that can be used to search for a specific element within a sorted array? | glaive | [
0.023274287581443787,
0.030654337257146835,
-0.03474534675478935,
-0.02694735676050186,
0.01495597418397665,
-0.04752567782998085,
-0.02859772928059101,
0.04757281392812729,
0.028920037671923637,
-0.03077717311680317,
0.03344086930155754,
0.015817025676369667,
-0.04281429573893547,
-0.0063... | 0.801316 | 0.783663 | 0.017653 |
You are tasked with implementing a CUDA kernel for calculating the accuracy of a neural network's predictions. The kernel should compare the predicted values (in the array N) with the target values (in the array T) and update the accuracy accordingly.
You need to implement the following CUDA kernel:
__global__ void a... | glaive | [
-0.00030338086071424186,
0.04799126088619232,
-0.023470604792237282,
-0.009881988167762756,
0.04149013012647629,
-0.030171802267432213,
-0.027634335681796074,
0.08530567586421967,
0.03647652640938759,
-0.03479446843266487,
0.030257632955908775,
0.02291199378669262,
-0.008503781631588936,
-... | 0.791918 | 0.774654 | 0.017265 |
You are tasked with implementing a data encryption and decryption system using VHDL. The system should use a custom encryption algorithm that requires 17 cycles for data encryption and 17 cycles for key generation. The system should be able to handle a maximum address of 16 and should support data text of 64 bits and m... | glaive | [
0.030980262905359268,
0.03258831799030304,
-0.016439242288470268,
-0.049041301012039185,
0.0351029671728611,
-0.0340002216398716,
-0.03200913593173027,
0.08187650889158249,
0.032058726996183395,
-0.02854541502892971,
0.03346328064799309,
0.027397198602557182,
-0.01722736470401287,
-0.01166... | 0.785246 | 0.768566 | 0.01668 |
You are tasked with creating a function that calculates the midpoint between two given points. The function should take two vectors as input and return a vector representing the midpoint between the two points.
Create a function called `calculateMidpoint` that takes two vectors `a` and `b` as input and returns a vecto... | glaive | [
0.029716119170188904,
0.015499988570809364,
-0.028560582548379898,
-0.030890990048646927,
0.046800706535577774,
-0.005704471841454506,
-0.029326917603611946,
0.06082574650645256,
0.05603600665926933,
-0.00036707217805087566,
0.026432206854224205,
0.035037800669670105,
-0.014577507972717285,
... | 0.791665 | 0.771891 | 0.019773 |
You are required to implement a function that computes cumulative log probabilities for a given set of input values. The function should take into account the logits, input IDs, and input lengths provided.
The input data consists of:
- `logits`: A 3D array of type T, representing the logits for each token in the vocab... | glaive | [
-0.014825278893113136,
0.04052213951945305,
-0.02637028507888317,
-0.01779881864786148,
0.04533869028091431,
-0.022252721711993217,
-0.022449199110269547,
0.06632884591817856,
0.032119251787662506,
-0.006204731296747923,
0.015241667628288269,
0.017179660499095917,
-0.012209529057145119,
-0... | 0.809043 | 0.770452 | 0.038591 |
You are tasked with implementing Conway's Game of Life, a cellular automaton devised by the mathematician John Conway. The game is a zero-player game, meaning that its evolution is determined by its initial state, requiring no further input. The game is played on an infinite two-dimensional grid of square cells, each o... | glaive | [
0.005450558383017778,
0.015405419282615185,
-0.02346642315387726,
-0.01766497828066349,
0.021744102239608765,
-0.035178907215595245,
-0.03648004308342934,
0.08549846708774567,
0.01816735230386257,
-0.024635685607790947,
0.0373377650976181,
0.02158181741833687,
-0.03978746011853218,
-0.0066... | 0.81679 | 0.77578 | 0.04101 |
You are tasked with implementing a program that samples from various probability distributions using nested sampling. This involves using different bounds and proposals for the sampling process. The program should be able to handle different models, such as Correlated Gaussian, Gaussian Shells, and Gaussian Mixture Mod... | glaive | [
-0.010868817567825317,
0.015026814304292202,
-0.02354697696864605,
-0.04267773777246475,
0.03512776643037796,
-0.015317714773118496,
-0.005446599330753088,
0.06735482066869736,
0.02492130920290947,
-0.007549030240625143,
0.027762772515416145,
0.046973004937171936,
-0.01849334128201008,
0.0... | 0.803583 | 0.787292 | 0.016291 |
You are tasked with implementing a Generalized Maximum Entropy Discrete Choice Model for the multinomial case using the Stata programming language. This model is more efficient than its maximum entropy and maximum likelihood counterparts because it incorporates noise terms in its results and performs better with small ... | glaive | [
-0.005864511243999004,
-0.005067057907581329,
-0.02592041902244091,
-0.04084905982017517,
0.02314048446714878,
-0.027296055108308792,
-0.03019598498940468,
0.06897256523370743,
0.04244641214609146,
-0.024914223700761795,
0.02246822416782379,
0.04093235731124878,
-0.017919402569532394,
0.01... | 0.797768 | 0.777691 | 0.020077 |
You are tasked with creating a program that calculates the probability of a quantum system being in a certain state. The system is defined by a set of qubits and a wavefunction amplitude function. You need to write a function to calculate the probability of the system being in a particular state, and then use optimizat... | glaive | [
-0.003360896371304989,
0.03321421518921852,
-0.03289107605814934,
-0.010493719018995762,
0.0448526069521904,
-0.02618241123855114,
-0.01827973872423172,
0.075088731944561,
0.04247317463159561,
0.014605667442083359,
0.018987532705068588,
0.03148403391242027,
-0.015147712081670761,
-0.017393... | 0.79973 | 0.76774 | 0.03199 |
You are tasked with writing a SQL query to calculate the sum of the quantity of store sales meeting specific criteria. The criteria include the year of sale (2000), marital status (M), education status (4 yr Degree), sales price ranges, country (United States), state (KY, GA, FL, MT, AR, SC, VA), and net profit ranges.... | glaive | [
0.019682489335536957,
0.008580117486417294,
-0.0469580739736557,
-0.027455905452370644,
0.0411735475063324,
0.0019110275898128748,
-0.06239857152104378,
0.02614550292491913,
0.048082709312438965,
0.008187209255993366,
0.03899243846535683,
0.037393778562545776,
-0.04102683812379837,
-0.0221... | 0.769261 | 0.745246 | 0.024015 |
You are tasked with creating a program that handles 2's complement arithmetic, specifically performing subtraction using 2's complement. The program should take an initial SByte value and subtract 8 from it, then output the result.
Additionally, you need to create a program that takes two input integers, base (b) and... | glaive | [
0.028314882889389992,
0.048134274780750275,
-0.02273409441113472,
-0.03908216953277588,
0.038698360323905945,
-0.03972216323018074,
-0.009497773833572865,
0.06991748511791229,
0.06017613783478737,
-0.03734876215457916,
0.015471439808607101,
0.029173465445637703,
-0.03626959025859833,
-0.00... | 0.815619 | 0.792907 | 0.022712 |
You are tasked with creating a function that takes in the number of opening and closing curly braces and returns a formatted string. The formatted string should indicate the number of opening and closing curly braces using the actual characters '{' and '}'.
Write a function that takes in two parameters: nOpen (number ... | glaive | [
0.02137991227209568,
0.04737993702292442,
-0.023044181987643242,
-0.036556221544742584,
0.03861803188920021,
-0.010013925842940807,
-0.02314159832894802,
0.09304288774728775,
0.03678269684314728,
-0.008188895881175995,
0.01604015938937664,
0.029384005814790726,
-0.043432462960481644,
-0.02... | 0.801952 | 0.78083 | 0.021122 |
You are tasked with implementing the Knuth-Morris-Pratt (KMP) algorithm for string searching in a stream of bytes. Your goal is to write a function that will take a stream of bytes and a byte array pattern, and return the index of the first occurrence of the pattern in the stream. If the pattern is not found, the funct... | glaive | [
-0.011105604469776154,
0.03521134704351425,
-0.014874211512506008,
-0.02926047332584858,
0.02695572003722191,
-0.034081991761922836,
-0.02042878232896328,
0.05903000757098198,
0.045644611120224,
-0.007413861807435751,
0.019082214683294296,
0.00820340309292078,
-0.019402319565415382,
0.0051... | 0.819901 | 0.79964 | 0.020261 |
You are tasked with creating a program that will take user input for a real number and then perform a specific operation on it. The program should prompt the user to enter a real number and then perform the following operation: if the number is positive, square it; if the number is negative, take its absolute value; if... | glaive | [
0.04886685684323311,
0.02838549017906189,
-0.0448349304497242,
-0.027112985029816628,
0.02499339170753956,
-0.010809822008013725,
0.005516928620636463,
0.06865689158439636,
0.05457542836666107,
-0.015185574069619179,
0.014158877544105053,
0.02887100912630558,
-0.03366902843117714,
-0.04103... | 0.803994 | 0.780499 | 0.023495 |
You are tasked with implementing a program that calculates the probability of a given quantum state. The program should use the given formula for amplitude and probability and then find the maximum probability within a specified range of values for the variables. Additionally, the program should generate a 3D plot and ... | glaive | [
0.003379601053893566,
0.03097711317241192,
-0.039020638912916183,
-0.026086583733558655,
0.048138320446014404,
-0.025167716667056084,
-0.019037092104554176,
0.07518801093101501,
0.04104273021221161,
-0.0040198033675551414,
0.028582876548171043,
0.03768158331513405,
-0.01492348499596119,
-0... | 0.791003 | 0.770265 | 0.020739 |
You are tasked with writing a program to perform vector addition using CUDA in C. The program should take input arguments for the vector size and block size. It should initialize two input arrays 'a' and 'b' with random integer values and then calculate the sum of the two arrays using both sequential and parallel appro... | glaive | [
0.005506088025867939,
0.05766400694847107,
-0.005912611726671457,
-0.011627945117652416,
0.02070617489516735,
-0.0008134701638482511,
-0.039493661373853683,
0.10506050288677216,
0.044778741896152496,
-0.0255866851657629,
0.0043764240108430386,
0.034552160650491714,
-0.010213743895292282,
-... | 0.790695 | 0.763471 | 0.027223 |
You are tasked with creating a CUDA kernel function that performs vector addition on two arrays and stores the result in a third array. The function signature should be as follows:
```cpp
extern "C" {
__global__ void Vector_Addition(int *a, int *b, int *c)
{
// Your code here
}
}
```
The kernel function sho... | glaive | [
0.010950155556201935,
0.055057138204574585,
-0.010565618984401226,
-0.018690552562475204,
0.03253691643476486,
0.004632517695426941,
-0.03317631408572197,
0.1173333078622818,
0.03728024661540985,
-0.011164315044879913,
0.013120672665536404,
0.04634301736950874,
-0.009468281641602516,
-0.00... | 0.799034 | 0.781621 | 0.017413 |
You are tasked with creating a function in Mathematica that calculates the line threshold for a given parameter. The line threshold is an option for the CardiacSegment function and can be a number between 0 and 1.
Write a function named "calculateLineThreshold" that takes a single parameter "thresholdValue" and retur... | glaive | [
0.006284618284553289,
0.0016225377330556512,
-0.03619900718331337,
-0.03915347903966904,
0.06180131062865257,
-0.028243647888302803,
-0.015233729965984821,
0.08457252383232117,
0.04384630545973778,
-0.0002836031198967248,
0.0007595787756145,
0.05783543363213539,
-0.018753867596387863,
-0.0... | 0.786258 | 0.766912 | 0.019346 |
How can I find the length of the longest increasing subsequence in a given array of numbers using Java? | glaive | [
-0.010506657883524895,
0.02612902782857418,
-0.041446201503276825,
-0.041992541402578354,
0.023790420964360237,
-0.01997598633170128,
-0.03483177348971367,
0.035043228417634964,
0.02168789692223072,
-0.0449536070227623,
0.01940133608877659,
0.016021285206079483,
-0.0469382181763649,
0.0084... | 0.801143 | 0.776981 | 0.024162 |
You are tasked with creating a function that takes in two arrays of integers, `arr` and `brr`. The function should return an array of integers that are missing from the `arr` array but present in the `brr` array. You need to implement the `missingNumbers` function using Kotlin and ensure that the returned array is sort... | glaive | [
0.019700584933161736,
0.031685613095760345,
-0.025009702891111374,
-0.03920331597328186,
0.05045338347554207,
-0.007234182674437761,
-0.020131167024374008,
0.056942153722047806,
0.01513640210032463,
-0.004417381715029478,
0.01666039414703846,
0.025039613246917725,
-0.03262517601251602,
0.0... | 0.820726 | 0.793621 | 0.027105 |
You are tasked with creating a program to generate the setup for a game of Catan. The setup includes the following components:
- Sea frames: a list of 6 elements consisting of 3 SingleHarbor and 3 TwoHarbor
- Harbor tokens: a list of 9 elements, where the first 5 elements consist of resources (Lumber, Wool, Grain, Bric... | glaive | [
0.05079645290970802,
0.011853656731545925,
-0.05119694769382477,
-0.030993474647402763,
0.030614936724305153,
-0.038465168327093124,
-0.028563454747200012,
0.06956659257411957,
0.05331910401582718,
-0.037338994443416595,
0.05265824496746063,
0.029992399737238884,
-0.04452134296298027,
0.00... | 0.794427 | 0.773736 | 0.020691 |
You are tasked with implementing a function that checks if a given functor `G` preserves the kernel of a morphism `f` in a category `C`. The given category `C` has zero morphisms, and the functor `G` preserves zero morphisms.
You need to define a function `preserves_kernel` that takes the following parameters:
1. A fu... | glaive | [
0.0024237236939370632,
0.0377039834856987,
-0.02797967940568924,
-0.015897473320364952,
0.04304666444659233,
-0.015881454572081566,
0.012302138842642307,
0.08555234223604202,
0.03411499783396721,
-0.02896493673324585,
-0.004284784663468599,
0.0402657613158226,
-0.008864614181220531,
0.0114... | 0.804674 | 0.78663 | 0.018044 |
You are tasked with creating a function in Wolfram Mathematica that takes in a prefix, postfix, index, and indicatorLength as input and returns a file name with the prefix followed by an index and terminated by the postfix. The length of the index part and accordingly the leading zeros is specified by indicatorLength (... | glaive | [
0.023776061832904816,
0.026986369863152504,
-0.025750650092959404,
-0.049125805497169495,
0.03248408064246178,
-0.02185012958943844,
-0.0130195626989007,
0.053277239203453064,
0.031653206795454025,
-0.009860152378678322,
0.027970559895038605,
0.032426245510578156,
-0.030434265732765198,
-0... | 0.80433 | 0.789876 | 0.014454 |
You are tasked with implementing a merge sort algorithm using CUDA and the HIP runtime. The goal is to sort an array of float4 elements using the merge sort algorithm and parallel processing. The array size is given by the variable listsize, and it is divided into multiple segments (divisions) for parallel processing. ... | glaive | [
0.01521178800612688,
0.03790629655122757,
-0.00272571062669158,
-0.020968178287148476,
0.04027106612920761,
-0.018825076520442963,
-0.029111625626683235,
0.07864278554916382,
0.050107166171073914,
-0.00881260447204113,
0.01592264696955681,
0.02525877207517624,
-0.004541856236755848,
0.0038... | 0.808964 | 0.784283 | 0.024681 |
You are tasked with implementing the matrix-vector operation in CUDA, using the following equation:
y := alpha*A*conj(x) + beta*y
where alpha and beta are scalars, x and y are vectors, and A is an m by n matrix.
The function signature is as follows:
```c
void magmablas_dgemv_conj_q(
magma_int_t m, magma_int_t n, d... | glaive | [
0.03425349295139313,
0.03147347271442413,
-0.028458023443818092,
-0.005881622899323702,
0.03692249208688736,
-0.02460276149213314,
-0.02813086286187172,
0.11894027143716812,
0.04228021949529648,
-0.020311152562499046,
0.02058229222893715,
0.03097069263458252,
-0.005598772782832384,
-0.0073... | 0.797302 | 0.773358 | 0.023944 |
Is there a way to find the two numbers in a list that have the closest sum using a programming code? | glaive | [
0.002288463292643428,
0.02297499030828476,
-0.029260216280817986,
-0.037689872086048126,
0.041866034269332886,
-0.02845442295074463,
-0.01543578039854765,
0.048477720469236374,
0.040897876024246216,
-0.03863704577088356,
0.02916887402534485,
0.0489533394575119,
-0.030320381745696068,
-0.01... | 0.807448 | 0.786486 | 0.020962 |
Can you provide a solution to the 8-puzzle problem using an algorithm? | glaive | [
0.02923750691115856,
0.0009068881627172232,
-0.005810907110571861,
-0.025591928511857986,
0.016414161771535873,
-0.02056177146732807,
-0.028302811086177826,
0.03407040610909462,
0.030671250075101852,
-0.0304319616407156,
0.00287825264967978,
0.019445162266492844,
-0.025668369606137276,
-0.... | 0.800783 | 0.771614 | 0.029169 |
Can you provide an algorithm to find the median of two sorted arrays? | glaive | [
0.01982838287949562,
0.007121912203729153,
-0.04104190692305565,
-0.028604455292224884,
0.0016581738600507379,
-0.021084465086460114,
-0.03558706119656563,
0.04527580365538597,
0.033881641924381256,
-0.04710185155272484,
0.029563970863819122,
0.012779727578163147,
-0.031626489013433456,
-0... | 0.794067 | 0.772912 | 0.021156 |
I need to create a function that can generate an empty vector or a singleton vector based on the input iterator. The function should handle both cases and ensure that the iterator meets the criteria for creating an empty or singleton vector. The empty vector should be able to handle any type of elements, and the single... | glaive | [
0.02936520427465439,
0.033833734691143036,
-0.018218325451016426,
-0.026719732210040092,
0.049350447952747345,
-0.020298300310969353,
-0.026055386289954185,
0.11798446625471115,
0.031129248440265656,
-0.0204556155949831,
0.00936315767467022,
0.02826504595577717,
-0.0035293297842144966,
-0.... | 0.798721 | 0.784361 | 0.01436 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.