user behavior – Displaying sections in the UI in Support Search as additional results

We have a large application where sections of its UI may be hard to find. In an attempt to ease the user’s navigation path, we plan on offering “shortcuts” from the Search functionality within the application.

Below is a quick mockup. As you can see, when someone types in a query, there will be two (2) sets of results – one are links to Support articles, while the other are links that directly jump to particular sections in the UI, both results are relevant to the query of course.

enter image description here

What do you think about offering this feature?

Part of me is telling me that these “shortcut” links should just be mentioned in the Support articles themselves, then when the user clicks on them, it’ll take them directly to the that particular section in the UI instead of creating a “whole-nother” subset of results; especially that both links can contain the same words.

php – How to implement traffic correlated ad rate algorithm for different sections of a forum

I’m working on a forum with at least 15 sections. I built an Ad management system that allow users to run their own Ad campaigns and place Ads on any of the sections that best suits their target audience.

I have created in the database a table named sections with the following fields:

Section_id, section_name, ad_rate

I have inserted the various section names into the database.
I have also inserted an estimated Ad rate for each of the sections.

However, I don’t want the Ad rates to be fixed. I want them correlated with traffic coming to that particular section.

Please I need an example approach (preferably in PHP) on how to design a rate algorithm that correlates the fixed Ad rate with the traffic levels.

at.algebraic topology – Set of all sections of a fiber bundle up to homotopy equivalence

Let $pi: E to B$ be a fiber bundle of (topological or differentiable) manifolds. Denote by $(B, E)_{pi}$ the set of all homotopy classes of sections of the bundle, i.e

begin{align}
(B, E)_pi &= {sigma: B to E | pisigma = text{id}_B }/sim \
sigma sim sigma’ &iff exists H: I times B to E | H_0 = sigma, H_1 = sigma’, pi H_t = text{id}_B
end{align}

Is it known how to calculate such set? With “calculate” I mean to reduce the computation of it to the computation of something more known, as the homology/cohomology/homotopy groups of $E$, $B$ or some combination of them.

ag.algebraic geometry – Is there a classification of higher degree generalizations of confocal conic sections?

1-parameter families of ellipses and hyperbolas with a given pair of points in the plane because their homes produce "double orthogonal foliages" of the plane. That is, once the focal points are specified, any point on the plane is both on a single ellipse and a single hyperbola, which are orthogonal to the point of intersection. For a given choice of households, the family is described by a single polynomial equation with three variables:

$$ P (x, y, a) = 0 $$

or $ a $ is the semi-major axis of the conic. When $ a $ is greater than half the distance between the foci, the curve is an ellipse and when it is less, the curve is a hyperbola.

With the limiting case of families of parabolas with a given focus and axis of symmetry, there do not seem to be any other families with 1 parameter of degree 2 curves with all the same properties:

  • They are defined by a single polynomial equation in coordinates and a single parameter.
  • They're splitting the plane twice, the two leaves from different domains for the parameter.
  • The two types of curves are orthogonal at the intersection point.

But surely there must be families of curves like this of higher degree.

I would be grateful for one of the following:

  • Specific examples of families with higher qualifications.
  • Any classification of families with higher qualifications.
  • Relevant terminology that can help in a document search.

html – Is there a tool to automatically create web sections?

Thanks for contributing to StackOverflow in Spanish with an answer!

  • Please make sure answer the question. Provide information and share your research!

But to avoid

  • Ask for help or clarification, or respond to other answers.
  • Make statements based on opinions; be sure to back them up with references or your own personal experience.

For more information, check out our tips on how to write great answers.

ios – Remove an item from a list of sections in SwiftUI

A little context
I create a simple application with CoreData and SwiftUI, I have two territory entities and users, the application displays a list of users in territory sections, I do a FetchRequest of users and territories , the problem is that when deleting a user I don't know delete the correct one, for example if I delete user 2 from section 2, delete 2 but from the first section.

I imagine that it is the set of indexes that is going badly, I would like to know how to pass the object as such to remove it from my set of users .

Here is my code:

import SwiftUI

struct ContentView: View {
    @Environment(.managedObjectContext) var moc
    @FetchRequest(entity: User.entity(), sortDescriptors: (NSSortDescriptor(keyPath: User.name, ascending: true))) var users: FetchedResults
    @FetchRequest(entity: Territory.entity(), sortDescriptors: (NSSortDescriptor(keyPath: Territory.name, ascending: true))) var territories: FetchedResults
    @State private var showAddUser = false


       var body: some View {
           GeometryReader{ geometry in
               NavigationView {
                   ZStack {

                       List {
                           ForEach(self.territories, id: .self) { territorie in
                            Section(header: Text(territorie.wrappedName)) {
                                ForEach(territorie.usersArray, id: .self) { user in
                                    NavigationLink(destination: UserView(user: user)) {
                                        VStack{
                                            HStack{
                                               Text("user")
                                                Spacer()
                                                Text(user.dayLastVisit)
                                                    .padding(.horizontal)
                                            }
                                            HStack {
                                                Text(user.wrappedEmoji)
                                                    .font(.largeTitle)
                                                VStack(alignment: .leading) {
                                                    Text("(user.wrappedName + " " + user.wrappedLastName)")
                                                        .font(.headline)
                                                    Text(user.wrappedType)

                                                }
                                                Spacer()
                                            }
                                        }

                                    }
                                }.onDelete(perform: self.deleteItem)
                            }
                           }



                       }
                       .listStyle(GroupedListStyle())
                       .environment(.horizontalSizeClass, .regular)

                       VStack {
                           Button(action:{ self.showAddRUser.toggle()}){
                               ButtonPlus(icon:"plus")}
                           .offset(x: (geometry.size.width * 0.40), y: (geometry.size.height  * 0.38))
                           .sheet(isPresented: self.$showAddUser){
                               NewUserView().environment(.managedObjectContext, self.moc)
                                  }
                       }
                   }
               .navigationBarTitle("Users")
                   .navigationBarItems( trailing: HStack {
                    EditButton()
                    Button(action:{self.showAddUser.toggle()}){
                    ButtonNew(text:"Nueva")}
                    }

                    .sheet(isPresented: self.$showAddUser){
                        NewUserView().environment(.managedObjectContext, self.moc)
                   }
                   )

               }
           }
       }
    func deleteItem(at offsets: IndexSet) {
        for offset in offsets { 
            let user = users(offset)

            //borarlo del context
            moc.delete(user)

        }
        try? moc.save()
    }

}

struct ContentView_Previews: PreviewProvider {
    static var previews: some View {
        ContentView()
    }
}

Questions

  • How to pass the right set of indexes?
  • Is there a better approach?

Remarks

  • I'm new to Swift, so I appreciate the help, suggestions and clarifications.
  • yes, more code was needed for more information on the logic of the application, just mention it in the comments and add it to the question.

Do restaurants really have ugly sections?

There is a theory that restaurants have a section for beautiful people and a section for ugly people.

Fox News has an article: restaurants hide ugly customers behind their backs, according to a social experiment.

The Straight Dope has a message on the forum: Are restaurants trying to "hide" ugly or unattractive customers?

However, I wouldn't really take in what Fox News and a random online forum have to say. Is there any merit to these allegations of ugly sections in restaurants?

Automatic numbering of sections in RMarkdown word_document output

I already used number_sections: true when the output is pdf_document or html_document, but when I want word_document, I get this argument used (number_sections: true).

NotepadImport sections of the documentation notepad?

How to use NotebookImport to retrieve "ExampleSection" cells?

nb = NotebookOpen("paclet:ref/RandomPrime");
NotebookImport(nb, "ExampleSection"->"Text")
(* {} *)

operating systems – Do Dekkers solutions to the problem of critical sections guarantee progression?

I was reading the section on concurrency control in William Stallings' book on operating systems. In this book, he gives three Dekker attempts to solve the problem of the critical section:

Attempt 1

+------------------------+------------------------+
| //process 0            | //process 1            |
| while (flag(1));       | while (flag(0));       |
| flag(0) = true;        | flag(1) = true;        |
| /* critical section*/; | /* critical section*/; |
| flag(0) = false;.      | flag(1) = false;.      |
+------------------------+------------------------+

Attempt 2

+------------------------+------------------------+
| //process 0            | //process 1            |
| flag(0) = true;        | flag(1) = true;        |
| while (flag(1));       | while (flag(0));       |
| /* critical section*/; | /* critical section*/; |
| flag(0) = false;       | flag(1) = false;       |
+------------------------+------------------------+

Attempt 3

+-----------------------+-----------------------+
| //process 0           | //process 1           |
| flag(0) = true;       | flag(1) = true;       |
| while (flag(1))       | while (flag(0))       |
| {                     | {                     |
|    flag(0) = false;   |    flag(1) = false;   |
|    /* delay */        |    /* delay */        |
|    flag(0) = true;    |    flag(1) = true;    |
| }                     | }                     |
| /* critical section*/ | /* critical section*/ |
| flag(0) = false;      | flag(1) = false;      |
+-----------------------+-----------------------+

Which of the above attempts ensures progress of the solution to the critical section?

The progress requirements are stated as follows in the book by Galvin et al:

If no process is running in its critical section and some processes wish to enter their critical sections, only the processes which do not run in their remaining sections can participate in the decision which will then enter its section critical, and this selection cannot be postponed indefinitely.

Here's how I feel:

  1. The remaining section is the code executed after the critical section. In attempt 1, if process 0 is busy waiting while(), it will be unlocked by process 1 by defining flag(1) at false, which is in the remaining section. This attempt therefore does not seem to guarantee progress.
  2. This attempt may cause a deadlock. Thus, he can postpone indefinitely the decision to let the process enter its critical section. Therefore, it does not guarantee the requirement for progress.
  3. This attempt can cause a blockage of life. Thus, like attempt 2, it can postpone the decision to let the process enter its critical section indefinitely and, therefore, it does not ensure progress requirements.

Am I correct with these points?