## html – Efeito CSS Transition no Link – Pseudo Active

Como posso deixar o efeito de transição fixo utilizando a pseudo de classe “active” a:active{…}, ou seja, quando o link foi clicado (ativado) o efeito permanece. Exemplo abaixo:

CSS:

``````body{
margin: 0;
font-family: arial; sans-serif;
font-size: 14px;
}
h1{
background: #333;
float: left;
margin: 20px;
}
a {
position: relative;
color: #fff;
text-decoration: none;
}

a:before {
content: "";
position: absolute;
width: 100%;
height: 3px;
bottom: 0;
left: 0;
background-color: #fff;
visibility: hidden;
-webkit-transform: scaleX(0);
transform: scaleX(0);
-webkit-transition: all 0.3s ease-in-out 0s;
transition: all 0.3s ease-in-out 0s;
}

a:hover:before {
visibility: visible;
-webkit-transform: scaleX(1);
transform: scaleX(1);
}
``````

HTML

``````<h1>
<a href="#">
Passe o Mouse
</a>
</h1>
``````

## plotting – Frenet frame in Pseudo Galilean Space

If I have the Fernet frames for an admissible curve in a pseudo Galilean space, which is given by:
t'(x) = kappa(x) n(x), n'(x) = tau(x) b(x) and b'(x) = tau(x) n(x), where tau and kappa are the torsion and the curvature, respectively. And the {t, n, b} are fernet trihedron. They are orthogonal and they have the following properties: t x n= epsilon b, n x b= 0 and b x t= – epsilon n, where epsilon is 1 or -1 (space like curve, time like curve). Note : The cross and dot product have different definition than the Euclidean space. How can I solve the fernet frame system to get the curve and How can i plot it?

https://www.researchgate.net/publication/265374684_Curves_in_pseudo-Galilean_geometry

## Derivation of a pseudo differential operator

I want to show that $$D ^ { alpha} _x a (x, D) u (x) = (2n) ^ {- n} langle tilde {u}, D ^ { alpha} _x (e ^ {ix xi} a (x, xi)) rangle$$, Where $$a (x, D)$$ is a pseudo-differential operator, and to calculate the derivative, I hesitate between these two answers:

begin {align *} D ^ { alpha} _x a (x, D) u = & D ^ { alpha} _x Big ( frac {1} {(2 pi) ^ n} int e ^ {ix xi} a (x, xi) widehat {u} ( xi) d xi Big) \ = & frac {1} {(2 pi) ^ n} int D ^ { alpha} _x (e ^ {ix xi} a (x, xi)) widehat {u} ( xi) d xi \ end {align *}
and
$$D ^ { alpha} _x a (x, D) u = frac {1} {(2 pi) ^ n} int e ^ {ix xi} D ^ { alpha} _x a (x , xi) widehat {u} ( xi) d xi$$

## Trend – The best way to create a pseudo or real trend list

I was wondering how to implement a list of trend posts and was curious to see if anyone had any ideas on how to implement a list.

More specifically, how could I try to monitor trends and update the list accordingly? The only real method I've come up with is:

• Go to the date a week ago (day-X) from the current date (day-y) and see how many votes a post (created on day-x) has collected up to day-y.
• Compare the votes each post collected from the previous step.
• Sort the posts (by the highest upvotes collected from day X to day Y) and display them in a list for the entire day.

I feel that this could be a large enough method to present trend contributions to users every day, but I feel that this method is fairly simple and only achieves a pseudo-sense for trends.

All comments, ideas, and suggestions on how to implement this implementation are very welcome.

## cte – ERROR: The column contains the pseudo data record PostgreSql

I am trying to create a temporary table from a list of values ​​passed at runtime to use for further selection links as follows:

``````with temp_ids as (select (:custIds) as custId)
select * into temporary table temp_cust_ids from temp_ids;
``````

But I get errors as

``````ERROR: column "custId" has pseudo-type record
``````

## Using the CSS pseudo class: not

I want to apply custom styles to all elements of a modal. First I try to override all styles that can be "inherited" for the "modal" class, for example in case I use Bootstrap.

So I have the following rule:

``````.modal * {
all: unset;
}
``````

Now I would specify styles for each element of the modal.
Problem: I also load my own styles onto other sheets, e.g. B. for buttons so that the rule above overwrites them. I want to be able to use it without increasing or adding specificity! Important in all of these styles that I'm going to load.
For example, I would use this HTML code for a button (which is under the Modal class):

register

And the CSS of the buttons:

``````.button-group .btn {
border-color: grey;
}
.button-group .btn-primary {
background: #2196F3;
border-color: blue;
}
``````

I tried unsuccessfully to change the start rule with the following: not ():

``````.modal:not(.button-group) * {
all: unset;
}

.modal *:not(.button-group) {
all: unset;
}

.modal * :not(.button-group) {
all: unset;
}
``````

I don't know if it works or if there is another way.

## Correction of the fishbowl effect in raycasting engine proposals (pseudo 3D projection)

I am writing a simple raycaster in Golang and have some problems understanding perspective correction. The code is simple, the main rendering loop is as follows:

``````    curVector := playerVector.NewRotated(-curFov / 2)
rotateStep := curFov / float64(screen.Width()) // Angles per screen row
// Traverse each row of our screen, cast a ray and render it to screen buffer
for i := 0; i <= screen.Width(); i++ {
curVector.Rotate(rotateStep)

hit, distance, tile, tileP := rayCast(curX, curY, curVector, viewDistance)

if hit {
// distToHeight is basically linear (screen.Height()/distance)
drawTexturedWallColumn(screen, tile, i, distToHeight(distance, screen.Height()), tileP) // Project walls on screen
}
// drawSpritesColumn(screen, i, curVector, distance) // Project sprites on screen
}
``````

So I just throw rays with even angular intervals and get this fishbowl effect:

So I understand that the problem lies with angular intervals and projected beams of the same length. I found this question. How can I correct an unwanted fisheye effect when I'm drawing a scene with raycasting? and tried to implement the same logic:

``````leftVector := playerVector.NewRotated(90)
// Traverse each row of our screen, cast a ray and render it to screen buffer
for i := 0; i <= screen.Width(); i++ {
progress := float64(i)/float64(screen.Width()) - 0.5 // -0.5 to 0.5
stepX := (playerVector.X + progress*(leftVector.X*2)) // *2 to make 90 FOV
stepY := (playerVector.Y + progress*(leftVector.Y*2))
curVector := Vector{X: stepX, Y: stepY}

hit, distance, tile, tileP := rayCast(curX, curY, curVector, viewDistance)

if hit {
// distToHeight is basically linear (screen.Height()/distance)
drawTexturedWallColumn(screen, tile, i, distToHeight(distance, screen.Height()), tileP) // Project walls on screen
}
// drawSpritesColumn(screen, i, curVector, distance) // Project sprites on screen
}
``````

But the result is almost the same (FOV variable is not used here, but it is about 90, it is not important at the moment). The difference is that this has a "more linear" fishbowl effect due to evenly distributed intervals (progress variable):

So I don't know how to fix it. I also tried to use the vertical distance (distance * cos).

## Correction of the fishbowl effect in raycasting engine proposals (pseudo 3D projection)

I am writing a simple raycaster about Golang and have some problems understanding perspective correction. The code is simple, the main rendering loop is as follows (yes, I used angles, no vectors, sorry: D, I started the project without any research, just from my head):

``````    lAngle := Degree{}.NewDegree(curAngle.Get() - curFov/2)

// Traverse each row of our screen, cast a ray and render it to screen buffer
for i := 0; i <= screen.Width(); i++ {
traversed := float64(i) / float64(screen.Width()) // How much of a screen space has been traversed (0.0 to 1.0, i.e. 0.3 is 30%)
angle := Degree{}.NewDegree(lAngle.Get() + (curFov * traversed))
hit, distance, tile, tileP := rayCast(curX, curY, angle, viewDistance)
correctedDist := distance*math.Cos(curAngle.Plus(-angle.Get())*(math.Pi/180))

if hit {
// distToHeight() is just tweaked 'distance/screen.Height'
drawTexturedWallColumn(screen, tile, i, distToHeight(correctedDist, screen.Height()), tileP) // Project walls on screen
}
drawSpritesColumn(screen, i, angle, distance) // Project sprites on screen
}
``````

Therefore I correct the distance based on the vertical distance from the camera (from this tutorial: http://www.permadi.com/tutorial/raycast/rayc8.html). It helps and the walls are almost straight now. But I'm not sure if the end result is what the projection should look like. For 90 FOV it is actually slightly deformed (60 FOV is the same but less noticeable):

I think it has to do with angles from which I project. I read that the angular step should not be linear and should increase towards the screen sides, but I don't really know that I would use some help with this

## co.combinatorics – Pseudo Hadamard Matrix – MathOverflow

What can you say about the matrices M with the following properties:
1) the rows and columns are indexed by the elements of a finite field with an even number q of elements;
2) All matrix entries are either 1 or -1;
3) The sum of the entries in each row and the sum of the entries in each column is zero.
4) the additive group of the field in (1) acts regularly on the rows and columns of the matrix M and the effect preserves M. that is, the (i, j) entry of M is equal to (g (i), g ( j)) – Enter M for each element of the field.

How comprehensive an answer or reference is is very much appreciated.

## Color spaces – pseudo high-bit grayscale – does this idea already exist?

You have already shown the exact reason why the implementation is not worthwhile.

The slight color should not be noticed.

Even the tiny differences in brightness would not be noticeable.

For example, can you read the text in this picture? It has two adjacent 8-bit grayscale values.

If you can see it, it is not your eyes … your monitor does not show the brightness values ​​exactly. (Look no further than the illusion of Hermann Grid or Mach Bands to show how badly your eyes and perception can actually deal with brightness.)

All of this requires a monitor that is high enough to be able to actively display the image. Monitors and color spaces are designed to show the strengths and weaknesses of the human eye.

I'm not going to go into the advantages and disadvantages of high bit depth images here, just some of their advantages that affect human perception.

TL; DR It's an interesting idea, but not only impractical, but also counterproductive. Only one machine can actually see the difference, but machines don't look at monitors.

If you have programming skills, I recommend you try this as an experiment if you are interested. Try mapping a 16-bit image to this format and displaying it side by side to see what you get.