A Fine Slice Of SQL Server
Stephane Laurent writes some code:
I implemented the framed closed curves exposed in this blog post, in Julia and R. In fact it is useless with R, because the rgl function
cylinder3dis faster and better.Here is the Julia implementation:
Click through for that code, as well as equivalent R code. H/T R-Bloggers
Comments closedSteven Sanderson simplifies things:
Today, we’re diving deep into the incredible world of R programming to explore the often-overlooked but extremely handy
unlist()function. If you’ve ever found yourself dealing with complex nested lists or vectors, this little gem can be a lifesaver. Theunlist()function is like a magician that simplifies your data structures, making them more manageable and easier to work with. Let’s unlock its magic together!
Click through to see how it works, including explanation and examples.
Comments closedMichael Mayer has a new R package for us:
This post is mainly about the third approach. Its beauty is that we get information about all interactions. The downside: it is as good/bad as partial dependence functions. And: the statistics are computationally very expensive to compute (of order n^2).
Different R packages offer some of these H-statistics, including {iml}, {gbm}, {flashlight}, and {vivid}. They all have their limitations. This is why I wrote the new R package {hstats}:
Click through for an overview of the package and an example of how it works.
Comments closedSteven Sanderson performs set intersection of vectors:
Welcome to another exciting blog post where we delve into the world of R programming. Today, we’ll be discussing the
intersect()function, a handy tool that helps us find the common elements shared between two or more vectors in R. Whether you’re a seasoned R programmer or just starting your journey, this function is sure to become a valuable addition to your toolkit.
Click through to see how the function works.
Comments closedSteven Sanderson performs a moving average:
The cumulative mean, also known as the running mean or moving average, provides us with a dynamic view of how the average value of a dataset changes as new observations are added incrementally. It is an invaluable tool in time-series analysis, trend identification, and smoothing noisy data.
Imagine you have a series of numeric values, and you want to find the average of the first observation, then the average of the first two observations, followed by the average of the first three, and so on. This iterative process generates the cumulative mean, painting a picture of how the data behaves over time.
Often times, we care about the moving average over a specific window, such as the last n periods. This particular post covers the moving average over the entire set of data.
Comments closedSteven Sanderson performs a breakdown:
Calculating percentages by group is a common task in data analysis. It allows you to understand the distribution of data within different categories. In this blog post, we’ll walk you through the process of calculating percentages by group using three popular R packages: Base R, dplyr, and data.table. To keep things simple, we will use the well-known Iris dataset.
The Iris dataset contains information about different species of iris flowers and their measurements, including sepal length, sepal width, petal length, and petal width. We will focus on the ‘Species’ column and calculate the percentage of each species in the dataset.
Read on for the three approaches. I think the Tidyverse approach is the easiest to understand in this case, though all three get you to the answer.
Comments closedSteven Sanderson makes a sub-list and checks it twice:
If you’re an aspiring data scientist or R programmer, you must be familiar with the powerful data structure called “lists.” Lists in R are collections of elements that can contain various data types such as vectors, matrices, data frames, or even other lists. They offer great flexibility and are widely used in many real-world scenarios.
In this blog post, we will explore one of the essential skills in working with lists: subsetting. Subsetting allows you to extract specific elements or portions of a list, helping you access and manipulate data efficiently. So, let’s dive into the world of list subsetting and learn some useful techniques along the way!
Read on for multiple ways of subsetting lists in base R.
Comments closedSteven Sanderson de-duplicates, starting with values:
In data analysis and programming, it’s common to encounter situations where you need to identify duplicate values within a dataset. Whether you’re a beginner or an experienced programmer, knowing how to find duplicate values is a fundamental skill. In this blog post, we will explore two different approaches to accomplish this task using base R functions and the dplyr package in R. By the end, you’ll have a clear understanding of how to detect and manage duplicate values in your own datasets.
From there, we get to see various ways to de-duplicate rows in R:
In data analysis and manipulation tasks, it’s common to encounter situations where we need to identify and handle duplicate rows in a dataset. In this blog post, we will explore three different approaches to finding duplicate rows in R: the base R method, the dplyr package, and the data.table package. We’ll compare their performance using the
benchmarkfunction and provide insights on when to use each approach. So, grab your coding gear, and let’s dive in!
Duplicate values is a relatively tricky one, with rows being much easier.
Comments closedPeter Baranovskiy breaks it down:
There are multiple tutorials available online on writing modular Shiny apps. So why one more? Well, when I just started with building modular apps myself, these didn’t do much for me. So I really only learned how to write modules when I had an opportunity to team up with an experienced R Shiny developer. The reason I guess is that Shiny modules is an advanced topic, and you typically get to writing modules only when you finally need to scale your apps – and keep opportunities for further scaling open. This typically means when your app goes into production. By then you probably have already developed multiple apps, and switching over to a way of thinking required to write modules may be challenging. If you don’t know what modules are, I recommend starting here and then coming back to this post. Otherwise, read on.
So, I decided to try a different approach and instead of building a simple modular app from scratch, to go in the opposite direction by breaking down a complex real-life app into modules. Here’s the app’s original non-modular code. Note a single
app.Rfile that contains the entire app.static_assets.Rincludes some object definitions which I moved to a separate file for convenience.calgary_crime_data_prep.Ris not part of the app; it is a data retrieval and cleaning script executed once a month with cron. Running the script each time the app launches would have made it extremely slow and would use way too much bandwidth, as the script downloads and processes 150+ Mb of data on each run.
Read on for the reasoning behind using modules, as well as Peter’s notes on the process.
Comments closedThe
datasetRhelps you generate a random datasets for your R project. It provides a preset random list of values with different data types (interval, ordinal, nominal values). It includes also a function for imputing a NULL, NA or missing values.
Click through to see how it works, the types of random data you can generate, and more.
1 Comment