mobile application – Questions for live-in-app-survey of live-bike-travel-info (Design comparison)

TL;DR: I am creating my own survey questions for a feature comparison. Need feedback on design and if I am missing something important.

I am creating a live-survey for comparing the status quo to the new design of a live-bike-travel-info within the biking app. Users see a map and their progress as well as a list of trip details/milestones (e.g. arrival in 20 min, overall delay of 4 min).

It will be a quasi-experimental design, as the new version will be rolled out with the newest update (no perfect randomization).

The Designer asked to compare and validate the two versions. We want to look into

  • Findability of feature in the app
  • Overall satisfaction
  • Overall ease of use
  • Ease of use map
  • Ease of use trip details
  • Clarity/Trust of information
  • Potential future engagement

Personally, I find the standardized questionnaires (e.g. SUS, WAMMI, etc.) to only be mildly applicable (too general) to compare this app feature. There is no need to compare it to other apps or app features.

I came up with the following questions (as did Nielsen Norman Group (Stover, Coyne, & Nielsen, 2002)).

5-point-Likert-Items from Totally disagree to Totally agree:

  • The (feature) is easy to find in the app. (Findability)
  • Navigating through the (feature) is easy to do.(Overall ease of use)
  • Interacting with the map (buttons/zooming in and out) is intuitive.(Map ease of use)
  • The information about travel milestones and arrival times is easy to understand.(Milestones ease of use)
  • I trust the displayed information in the (feature) the be correct.(Functionality)
    Overall, I am satisfied with the (feature). (Satisfaction)
  • I can see myself using the (feature) more often. (Engagement)

Goal would be to compare the overall mean scores and if significant, do an item comparison.

I would appreciate any feedback you have. Have you created your own items/scales before? Something to keep in mind (e.g. no. of questions, reversed scale, etc.)?

comparison – Sorting an array with x sorted subarrays

I have been given two True/False questions regarding sorting an array. The questions are as following –

Question A

Given an array A with 3n keys that contains three equal parts
A(1,n), A(n+1,2n) and A(2n+1,3n), each with n keys. Each part is
sorted. Is possible to sort the keys of A into a
new array B in O(n) steps (worst case)?

Question B

Given an array A with 10n keys that are comparable using a binary function that returns which element
is bigger or if the elements are equal. The array is split into n equal parts, each
with 10 keys. Each part is sorted. Is it possible to sort the keys of
A into a new array B in O(n) steps (worst case)?

The solution to question A is that we can use merge() fucntion from MergeSort to sort the array.

The solution to question B is that it is not possible, as it violates the Ω(nlog(n)) lower bound for comparison based sorting algorithms

And I fail to see the difference between the two questions.. Is it because in question B we first need to apply the function? Why does it prohibits us from using merge() aswell? I don’t see the logic behind the assumption that the two scenarios are different and I feel that I’m missing something important.

postgresql – Is there an index that would support comparison of 2-tuple values?

I want to implement cursor-based pagination for a large data set.

With OFFSET based pagination, when the user wants page N, you just OFFSET N * page_size.
The query ends up like:

SELECT *
FROM books
ORDER BY id
OFFSET 100000
LIMIT 10;

But OFFSET gets slower the larger the value it’s given because PostgreSQL has to load and discard the preceding rows.

A cursor-based approach is where we tell the user “here’s page N, and since the last record on it has id of X, to get the next page you should ask me for records with id > X.”
The query ends up like:

SELECT *
FROM books
WHERE id > 100000
ORDER BY id
LIMIT 10;

In that case, PostgreSQL can load only the needed rows.

That works great when sorting by id.
But I’d like to be able to sort by other columns – for instance, by title – and still paginate.

The problem is that title is not unique. So if the final record on page N has the title “About Weasels” and there are multiple books with that title, requesting the next page with WHERE title > 'About Weasels' may skip some of them.

I can get unique values by having the user request WHERE (title, id) > ('About Weasels', 100000), but that performs poorly because PostgreSQL has to compute (title, id) for every row.

I tried adding an index to pre-compute that 2-tuple: CREATE INDEX books_title_and_id ON books (title, id);

…but that index makes no difference to the query plan.

Is there an index I could create which would speed up this query?

approximation – Fast text comparison algorithm for long texts

I want to calculate a similarity ratio between two long texts (by “long”, I imply something around 1000 characters or higher). For example, two texts with only one word changing should have a ratio approaching 100%, and a text compared to (the same one + another being the same size) should be 50%.

I know about texts comparison algorithms like Levenshtein or Jaro, but they tend to be too computationally-expensive in my case, given that I am doing comparisons of one text with several thousands of other ones.

I tried to experiment with ssdeep library (for those who do not know: it is an algorithm that splits a blob into several parts, hash each of these parts, then regroup them in a summary hash; this is an example of “fuzzy hashing”). It was promising since it reduces the text to an hash we just have to compare with another. However, since it deals on a binary level, the characters are often cut, which makes the comparison inaccurrate. Plus, the comparison does not work if the texts have a different size.

Is there a better solution that could fit this case, given that as I stated, I am privileging the low complexity over the complete accuracy?

REHub – Price Comparison, Multi Vendor Marketplace, Affiliate Marketing, Community Theme | NullScripts

REHub – Hybrid wordpress template with enhanced affiliate, coupon, directory functions with social unique features, WOOCOMMERCE EXTENDED + Multivendor and user submit + Extended Buddypress + BBPress + Content EGG + Affiliate links builder and much more

Demo:…

.

Comparison of ISPmanager 6 server panels with Plesk, cPanel and VestaCP.


Each of the panels is easy to manage, but there are so many tools in Cpanel that at first the user will have to use a global search.

All is well in terms of security. All panels have a variety of functions and insertions.

Data backup is also important. ISPmanager has enough functions for saving at each tariff. information can be saved locally or uploaded to a third-party resource and protected with a password.

What can you say about each of these panels and which one would you choose yourself?

Picture Comparison Code Not Working Properly

I am still very much a beginner in programming and am facing a problem with a Java code. I would be very thankful for suggestions and comments. The problem is as following:

I found a Java code online that is designed to compare two pictures and highlight the differences between them. However, the way the code works is by using a loop that compares the RGB value of each pixel of the two pictures and highlights it in a certain color if the value is equal. This however results in a problem that even the slightest shift in camera angle or lighting conditions between the two pictures leads to a different RGB value of the pixels making the code highlight them as a difference even though the pictures are mostly identical. The code is written below and i have added the link to photos showing examples of the outcome of the code. What would you suggest i change in the code? Thank you for your help in advance.

The code:

import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

import javax.imageio.ImageIO;
public class PictureOverlayTest {
/*
* Four variables, three for the wanted BufferedImages, one String for the
* Path of the third Image, which does not already exist.
*/

private BufferedImage image1;
private BufferedImage image2;
private BufferedImage image3;

private String pathImage3;

public PictureOverlayTest(String filePathAndName1, String filePathAndName2,
String filePathAndName3) throws IOException {
/*
* Constructor in order to keep this method reusable and clean. Needs
* three Strings. The paths and Filenames of all three images. Image 1
* and 2 should exist already, Image 3 will be created if all
* requirements are met. Constructor creates the first two buffered
* images, sets all needed variables and starts the checkAndCompare()
* method
*/

File file = new File(filePathAndName1);
this.image1 = ImageIO.read(file);

file = new File(filePathAndName2);
this.image2 = ImageIO.read(file);

this.pathImage3 = filePathAndName3;
checkAndCompare();
}

private void checkAndCompare() throws IOException {
/*
* This function creates the Color blue, compares the sizes of both
* pictures and if they are the same, creates a third image. Then it
* loops through the two images and compares each pixel. If the pixels
* are the same, the third image gets a blue pixel at that point
*/

Color blue = Color.blue;
Color yellow = Color.yellow;

if (image1.getHeight() == image2.getHeight()
&& image1.getWidth() == image2.getWidth()) {

image3 = new BufferedImage(image1.getWidth(), image1.getHeight(),
image1.getType());
for (int y = 0; y < image1.getHeight(); y++) {
for (int x = 0; x < image1.getWidth(); x++) {

int colorImage1 = image1.getRGB(x, y);
int colorImage2 = image2.getRGB(x, y);

if (colorImage1 == colorImage2) {

image3.setRGB(x, y, blue.getRGB());

} else {
image3.setRGB(x, y, yellow.getRGB());
// Whatever Color you want. By default it is black.

}

}
}
savePicture3();
System.out.println(“Message: Image comparison is done”);

} else {

System.out.println(“Error: Image dimensions do not match”);

}
SEMrush

}

private void savePicture3() throws IOException {
/*
* This method saves the created Image into a file onto your computer.
* The if() statement is used to check if the file was successfully
* created, in order to avoid unwanted errors. Keep in mind, that you
* have to change the “bmp” in ImageIO.write() to whatever format you
* actually want
*/

File file = new File(pathImage3);
if (file.createNewFile()) {
ImageIO.write(image3, “bmp”, file);
}
}

}

import java.io.IOException;

public class Main {

public static void main(String() args) {
// TODO Auto-generated method stub

try {
PictureOverlayTest test = new PictureOverlayTest(
“C:\Users\Rabee Taha\Desktop\Java Test Pics\test1.png”,
“C:\Users\Rabee Taha\Desktop\Java Test Pics\test2.png”,
“C:\Users\Rabee Taha\Desktop\Java Test Pics\test3.png”);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

}

Here is the link to example images of the outcome ( https://postimg.cc/gallery/rkXfPr7 )

 

ag.algebraic geometry – Comparison of weight filtration on cohomology of complex manifold

Let $X$ be a smooth scheme of finite type over $mathbb{Z}$ (or let’s say a finitely generated $mathbb{Z}$ algebra). To each prime $p in mathbb{Z}$ we can consider the $mathbb{F}_p$ variety $$X_{mathbb{F}_p}=X times_{mathbb{Z}} mathbb{F}_p$$ and the $overline{mathbb{F}_p}$ variety $$X_{overline{mathbb{F}_p}}=X times_{mathbb{Z}} overline{mathbb{F}_p}=X_{mathbb{F}_p}times_{mathbb{F}_p} overline{mathbb{F}_p}$$ (I’m omitting spec everywhere to lighten the notations a little bit).

In this way, the etale cohomology $H^{*}(X_{overline{mathbb{F}_p}},overline{mathbb{Q}}_{ell})$ gets endowed with a Frobenius morphism and we can consider the associated increasing weight filtration $W^{i}_m$.

If one now considers $X_{mathbb{C}}=X times_{mathbb{Z}}mathbb{C}$ this is a smooth complex algebraic variety. We now from comparison theorems that $$H^{*}_{etale}(X_{mathbb{C}},overline{mathbb{Q}}_{ell})=H^{*}_{simp}(X_{mathbb{C}}(mathbb{C}),overline{mathbb{Q}}_{ell}) $$ where on the right side we have the usual simplicial cohomology.

We moreover know that for $p >>>1$ we will have $$H^{*}_{etale}(X_{mathbb{C}},overline{mathbb{Q}}_{ell}) cong H^{*}(X_{overline{mathbb{F}_p}},overline{mathbb{Q}}_{ell}) .$$ In this way, we can endow the cohomology $H^{*}_{simp}(X_{mathbb{C}}(mathbb{C}),overline{mathbb{Q}}_{ell}) $ and so the cohomology with complex coefficients $H^{*}_{simp}(X_{mathbb{C}}(mathbb{C}),mathbb{C}) $ with a weight filtration which I’m denoting $W^{*}_{m,p}$.

On the other side, Deligne’s theory of mixed Hodge structures, endowes $H^{*}_{simp}(X_{mathbb{C}}(mathbb{C}),mathbb{C})$ with another weight filtration $W^{*}_{m}$. Do these two filtrations coincide in general? Does the filtration $W_{m,p}$ depends on the prime chosen?

I know that there are some invariants which relate the two filtrations. One can define the E-polynomial for example $$E_p(X_{mathbb{C}},q)=sum_{m,k}(-1)^k dim frac{W^{k}_{m,p}}{W^{k}_{m-1,p}}q^{m} $$ and analogously $$E(X_{mathbb{C}},q)=sum_{k}(-1)^ksum_{i+j=r} h^{i,j;k}q^r $$ where $$h^{i,j;k}=dim Gr_W^{i+j} Gr_F^{i} H^{k}(X_{mathbb{C}},mathbb{C})$$ are the Hodge numbers.

One can show that $E_p(X_{mathbb{C}},q)=E(X_{mathbb{C}},q)$ using the additivity with respect to locally closed decompisition of both polynomials and the statement for projective varieties which is true as everything is pure.

differential equations – NDEigensystem convergence and comparison to DEigensystem

Consider the following eigenvalue differential equation

$$
-u_n”(x)+x^2u_n(x)=E_nu_n(x),qquad xin(-infty,infty).
$$

If you know a little bit of physics, you would know that this is the differential equation for a quantum harmonic oscillator, and that the energies are exactly given by

$$
E_n=2(n+1).
$$

We can also confirm this using Mathematica

 {eig, func} = DEigensystem(-u''(x) + x^2*u(x), u(x), {x, -Infinity, Infinity}, 5);
 ListPlot(eig)

exact

This is the expected result. But things go wrong quickly if we want to solve this using numerically. In that case our code will look like

 {eig, func} = NDEigensystem(-u''(x) + x^2*u(x), u(x), {x, -1000, 1000}, 10);
 ListPlot(eig)

numerical

We expect the numerical calculation to converge to the exact calculation when we increase the bounds of $x$ but that does not happen. As we increase the boundaries, the energy eigenvalues blow up, and they do not converge.

I had the same experience using NDEigensystem for other complicated scenarios (NDEigensystem eigenvalue convergence problem), and therefore I wanted to frame the problem in this simple case. Is there something fundamental, or am I completely butchering NDEigensystem. Any help regarding this question and the linked question would be appreciated.