glimmer-dsl-swt | Glimmer DSL for SWT

by AndyObtiva Ruby Version: Current License: MIT

Download this library from

kandi X-RAY | glimmer-dsl-swt Summary

glimmer-dsl-swt is a Ruby library typically used in Programming Style, Framework applications. glimmer-dsl-swt has no bugs, it has no vulnerabilities, it has a Permissive License and it has low support. You can download it from GitHub, GitLab.

Glimmer DSL for SWT (JRuby Desktop Development GUI Framework)

Support

Quality

Security

License

Reuse

kandi-support Support

glimmer-dsl-swt has a low active ecosystem.
It has 45 star(s) with 5 fork(s). There are 2 watchers for this library.
It had no major release in the last 12 months.
There are 1 open issues and 9 have been closed. On average issues are closed in 3 days. There are no pull requests.
It has a neutral sentiment in the developer community.
The latest version of glimmer-dsl-swt is current.

glimmer-dsl-swt Support

Best in #Ruby

Average in #Ruby

glimmer-dsl-swt Support

Best in #Ruby

Average in #Ruby

quality kandi Quality

glimmer-dsl-swt has 0 bugs and 0 code smells.

glimmer-dsl-swt Quality

Best in #Ruby

Average in #Ruby

glimmer-dsl-swt Quality

Best in #Ruby

Average in #Ruby

security Security

glimmer-dsl-swt has no vulnerabilities reported, and its dependent libraries have no vulnerabilities reported.
glimmer-dsl-swt code analysis shows 0 unresolved vulnerabilities.
There are 0 security hotspots that need review.

glimmer-dsl-swt Security

Best in #Ruby

Average in #Ruby

glimmer-dsl-swt Security

Best in #Ruby

Average in #Ruby

license License

glimmer-dsl-swt is licensed under the MIT License. This license is Permissive.
Permissive licenses have the least restrictions, and you can use them in most projects.

glimmer-dsl-swt License

Best in #Ruby

Average in #Ruby

glimmer-dsl-swt License

Best in #Ruby

Average in #Ruby

build Reuse

glimmer-dsl-swt releases are not available. You will need to build from source code and install.
Installation instructions, examples and code snippets are available.

glimmer-dsl-swt Reuse

Best in #Ruby

Average in #Ruby

glimmer-dsl-swt Reuse

Best in #Ruby

Average in #Ruby

Top functions reviewed by kandi - BETA

kandi has reviewed glimmer-dsl-swt and discovered the below as its top functions. This is intended to give you an instant insight into glimmer-dsl-swt implemented functionality, and help decide if they suit your requirements.

Display the task .
Extracts the options from the options hash .
Extracts the options from the environment
Launch the application .
Extracts an options from the application path .
Launch the application .

glimmer-dsl-swt Key Features

These features have been suggested. You might see them in a future version of Glimmer. You are welcome to contribute more feature suggestions.

glimmer-dsl-swt Examples and Code Snippets

See all related Code Snippets

Hello, World! Sample

Copy

Download

include Glimmer

shell {
  text "Glimmer"
  label {
    text "Hello, World!"
  }
}.open

Hello, Table! Sample

Copy

Download

# ... model code precedes
shell {
  grid_layout
  
  text 'Hello, Table!'
  background_image File.expand_path('hello_table/baseball_park.png', __dir__)
  
  label {
    layout_data :center, :center, true, false
    
    text 'BASEBALL PLAYOFF SCHEDULE'
    background :transparent
    foreground rgb(94, 107, 103)
    font name: 'Optima', height: 38, style: :bold
  }
  
  combo(:read_only) {
    layout_data :center, :center, true, false
    selection bind(BaseballGame, :playoff_type)
    font height: 14
  }
  
  table(:editable) { |table_proxy|
    layout_data :fill, :fill, true, true
  
    table_column {
      text 'Game Date'
      width 150
      sort_property :date # ensure sorting by real date value (not `game_date` string specified in items below)
      editor :date_drop_down, property: :date_time
    }
    table_column {
      text 'Game Time'
      width 150
      sort_property :time # ensure sorting by real time value (not `game_time` string specified in items below)
      editor :time, property: :date_time
    }
    table_column {
      text 'Ballpark'
      width 180
      editor :none
    }
    table_column {
      text 'Home Team'
      width 150
      editor :combo, :read_only # read_only is simply an SWT style passed to combo widget
    }
    table_column {
      text 'Away Team'
      width 150
      editor :combo, :read_only # read_only is simply an SWT style passed to combo widget
    }
    table_column {
      text 'Promotion'
      width 150
      # default text editor is used here
    }
    
    # Data-bind table items (rows) to a model collection property, specifying column properties ordering per nested model
    items bind(BaseballGame, :schedule), column_properties(:game_date, :game_time, :ballpark, :home_team, :away_team, :promotion)
    
    # Data-bind table selection
    selection bind(BaseballGame, :selected_game)
    
    # Default initial sort property
    sort_property :date
    
    # Sort by these additional properties after handling sort by the column the user clicked
    additional_sort_properties :date, :time, :home_team, :away_team, :ballpark, :promotion
    
    menu {
      menu_item {
        text 'Book'
        
        on_widget_selected {
          book_selected_game
        }
      }
    }
  }
  
  button {
    text 'Book Selected Game'
    layout_data :center, :center, true, false
    font height: 14
    enabled bind(BaseballGame, :selected_game)
    
    on_widget_selected {
      book_selected_game
    }
  }
}.open
# ...

Tetris

Copy

Download

# ... more code resides in other files (navigate sample files to learn more)
shell(:no_resize) {
  grid_layout {
    num_columns 2
    make_columns_equal_width false
    margin_width 0
    margin_height 0
    horizontal_spacing 0
  }
  
  text 'Glimmer Tetris'
  minimum_size 475, 500
  image tetris_icon

  tetris_menu_bar(game: game)

  playfield(game_playfield: game.playfield, playfield_width: playfield_width, playfield_height: playfield_height, block_size: BLOCK_SIZE)

  score_lane(game: game, block_size: BLOCK_SIZE) {
    layout_data(:fill, :fill, true, true)
  }
}
# ...

Pre-requisites

Copy

Download

rvm install jruby-9.2.17.0

Option 1: Direct Install

Copy

Download

jgem install glimmer-dsl-swt

Option 2: Bundler

Copy

Download

gem 'glimmer-dsl-swt', '~&gt; 4.19.0.1'

Glimmer Command

Copy

Download

glimmer

Girb (Glimmer irb) Command

Copy

Download

girb

Glimmer GUI DSL Syntax

Copy

Download

table

Samples

Copy

Download

glimmer samples

Packaging & Distribution

Copy

Download

glimmer package

See all related Code Snippets

Community Discussions

Trending Discussions on Programming Style

Use for loop or multiple prints?
Why doesn't the rangeCheck method in the java.util.ArrayList class check for negative index?
Are java streams able to lazilly reduce from map/filter conditions?
Are any{}, all{}, and none{} lazy operations in Kotlin?
Use map and zip to be more func style in 2 for loops
malloc a "member" of struct v.s. whole struct when struct is quite simple
Difference between Running time and Execution time in algorithm?
Lifetime of get method in postgres Rust
Is there a way to implement mapcar in Common Lisp using only applicative programming and avoiding recursion or iteration as programming styles?
Create TKinter label using class method

Trending Discussions on Programming Style

QUESTION

Use for loop or multiple prints?

Asked 2022-Mar-01 at 21:31

What programming style should I use?

...
print(1)
print(2)

...
for i in range(1, 3):
    print(i)

The output is the same 1 and on the next line 2, but which version should I use as a Python programmer?

I mean the first version is redundant or not?

ANSWER

Answered 2022-Mar-01 at 21:31

It depends.

There is an old rule "three or more, use for". (source)

On the other hand, sometimes unrolling a loop can offer a speed-up. (But that's generally more true in C or assembly.)

You should do what makes your program more clear.

For example, in the code below, I wrote out the calculations for the ABD matrix of a fiber reinforced composite laminate, because making nested loops would make it more complex in this case;

    for la, z2, z3 in zip(layers, lz2, lz3):
        # first row
        ABD[0][0] += la.Q̅11 * la.thickness  # Hyer:1998, p. 290
        ABD[0][1] += la.Q̅12 * la.thickness
        ABD[0][2] += la.Q̅16 * la.thickness
        ABD[0][3] += la.Q̅11 * z2
        ABD[0][4] += la.Q̅12 * z2
        ABD[0][5] += la.Q̅16 * z2
        # second row
        ABD[1][0] += la.Q̅12 * la.thickness
        ABD[1][1] += la.Q̅22 * la.thickness
        ABD[1][2] += la.Q̅26 * la.thickness
        ABD[1][3] += la.Q̅12 * z2
        ABD[1][4] += la.Q̅22 * z2
        ABD[1][5] += la.Q̅26 * z2
        # third row
        ABD[2][0] += la.Q̅16 * la.thickness
        ABD[2][1] += la.Q̅26 * la.thickness
        ABD[2][2] += la.Q̅66 * la.thickness
        ABD[2][3] += la.Q̅16 * z2
        ABD[2][4] += la.Q̅26 * z2
        ABD[2][5] += la.Q̅66 * z2
        # fourth row
        ABD[3][0] += la.Q̅11 * z2
        ABD[3][1] += la.Q̅12 * z2
        ABD[3][2] += la.Q̅16 * z2
        ABD[3][3] += la.Q̅11 * z3
        ABD[3][4] += la.Q̅12 * z3
        ABD[3][5] += la.Q̅16 * z3
        # fifth row
        ABD[4][0] += la.Q̅12 * z2
        ABD[4][1] += la.Q̅22 * z2
        ABD[4][2] += la.Q̅26 * z2
        ABD[4][3] += la.Q̅12 * z3
        ABD[4][4] += la.Q̅22 * z3
        ABD[4][5] += la.Q̅26 * z3
        # sixth row
        ABD[5][0] += la.Q̅16 * z2
        ABD[5][1] += la.Q̅26 * z2
        ABD[5][2] += la.Q̅66 * z2
        ABD[5][3] += la.Q̅16 * z3
        ABD[5][4] += la.Q̅26 * z3
        ABD[5][5] += la.Q̅66 * z3
        # Calculate unit thermal stress resultants.
        # Hyer:1998, p. 445
        Ntx += (la.Q̅11 * la.αx + la.Q̅12 * la.αy + la.Q̅16 * la.αxy) * la.thickness
        Nty += (la.Q̅12 * la.αx + la.Q̅22 * la.αy + la.Q̅26 * la.αxy) * la.thickness
        Ntxy += (la.Q̅16 * la.αx + la.Q̅26 * la.αy + la.Q̅66 * la.αxy) * la.thickness
        # Calculate H matrix (derived from Barbero:2018, p. 181)
        sb = 5 / 4 * (la.thickness - 4 * z3 / thickness ** 2)
        H[0][0] += la.Q̅s44 * sb
        H[0][1] += la.Q̅s45 * sb
        H[1][0] += la.Q̅s45 * sb
        H[1][1] += la.Q̅s55 * sb
        # Calculate E3
        c3 += la.thickness / la.E3

Source https://stackoverflow.com/questions/71314703

QUESTION

Why doesn't the rangeCheck method in the java.util.ArrayList class check for negative index?

Asked 2022-Feb-28 at 15:32

/**
 * Checks if the given index is in range.  If not, throws an appropriate
 * runtime exception.  This method does *not* check if the index is
 * negative: It is always used immediately prior to an array access,
 * which throws an ArrayIndexOutOfBoundsException if index is negative.
 */
private void rangeCheck(int index) {
    if (index >= size)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

From: jdk/ArrayList.java at jdk8-b120 · openjdk/jdk · GitHub

If we write the following code, both indexes are out of bounds, but the exception types are different.

import java.util.ArrayList;
import java.util.List;

public class Test {

    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("");

        try {
            list.get(-1);
        } catch (Exception e) {
            e.printStackTrace();
        }

        try {
            list.get(1);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

The output is as follows:

java.lang.ArrayIndexOutOfBoundsException: -1
    at java.util.ArrayList.elementData(ArrayList.java:424)
    at java.util.ArrayList.get(ArrayList.java:437)
    at Test.main(Test.java:11)
java.lang.IndexOutOfBoundsException: Index: 1, Size: 1
    at java.util.ArrayList.rangeCheck(ArrayList.java:659)
    at java.util.ArrayList.get(ArrayList.java:435)
    at Test.main(Test.java:17)

Related question:

Why does rangeCheckForAdd method in the java.util.ArrayList check for negative index?
Why doesn't java.util.Arrays.ArrayList do index out-of-bounds checking?

What confuses me is why their implementations are inconsistent? Are these methods written by different people with their own programming style? In other words, if out-of-bounds exceptions will eventually fire, then there is no need to check.

ANSWER

Answered 2022-Feb-28 at 14:23

It's a micro-optimization. For code clarity you might prefer the same exception for both, but when you're in a hot loop you'll want to avoid an unnecessary operation. ArrayList being an old class, the effect this has may have varied between times and JDK versions. If someone has enough interest they could benchmark it with 1.8 and newer JDKs to see how much of an optimization it is for get().

Since accessing a negative array index will fail anyway, there is no need to check for it. However the size of the ArrayList is not always the same as the size of its internal array, so it needs to be checked explicitly.

As to why rangeCheckForAdd does check for negative indexes, good question. Adding is slow anyway, so the micro-optimization wouldn't make much of a difference. Maybe they wanted consistent error messaging here.

Source https://stackoverflow.com/questions/71295603

QUESTION

Are java streams able to lazilly reduce from map/filter conditions?

Asked 2022-Jan-12 at 09:30

I am using a functional programming style to solve the Leetcode easy question, Count the Number of Consistent Strings. The premise of this question is simple: count the amount of values for which the predicate of "all values are in another set" holds.

I have two approaches, one which I am fairly certain behaves as I want it to, and the other which I am less sure about. Both produce the correct output, but ideally they would stop evaluating other elements after the output is in a final state.

    public int countConsistentStrings(String allowed, String[] words) {
        final Set<Character> set = allowed.chars()
          .mapToObj(c -> (char)c)
          .collect(Collectors.toCollection(HashSet::new));
        return (int)Arrays.stream(words)
          .filter(word ->
                  word.chars()
                  .allMatch(c -> set.contains((char)c))
                 )
          .count();
    }

In this solution, to the best of my knowledge, the allMatch statement will terminate and evaluate to false at the first instance of c for which the predicate does not hold true, skipping the other values in that stream.

    public int countConsistentStrings(String allowed, String[] words) {
        Set<Character> set = allowed.chars()
          .mapToObj(c -> (char)c)
          .collect(Collectors.toCollection(HashSet::new));
        return (int)Arrays.stream(words)
          .filter(word ->
                  word.chars()
                  .mapToObj(c -> set.contains((char)c))
                  .reduce((a,b) -> a&&b)
                  .orElse(false)
                 )
          .count();
    }

In this solution, the same logic is used but instead of allMatch, I use map and then reduce. Logically, after a single false value comes from the map stage, reduce will always evaluate to false. I know Java streams are lazy, but I am unsure when they ''know'' just how lazy they can be. Will this be less efficient than using allMatch or will laziness ensure the same operation?

Lastly, in this code, we can see that the value for x will always be 0 as after filtering for only positive numbers, the sum of them will always be positive (assume no overflow) so taking the minimum of positive numbers and a hardcoded 0 will be 0. Will the stream be lazy enough to evaluate this to 0 always, or will it work to reduce every element after the filter anyways?

List<Integer> list = new ArrayList<>();
...
/*Some values added to list*/
...
int x = list.stream()
        .filter(i -> i >= 0)
        .reduce((a,b) -> Math.min(a+b, 0))
        .orElse(0);

To summarize the above, how does one know when the Java stream will be lazy? There are lazy opportunities that I see in the code, but how can I guarantee that my code will be as lazy as possible?

ANSWER

Answered 2022-Jan-12 at 09:30

The actual term you’re asking for is short-circuiting

Further, some operations are deemed short-circuiting operations. An intermediate operation is short-circuiting if, when presented with infinite input, it may produce a finite stream as a result. A terminal operation is short-circuiting if, when presented with infinite input, it may terminate in finite time. Having a short-circuiting operation in the pipeline is a necessary, but not sufficient, condition for the processing of an infinite stream to terminate normally in finite time.

The term “lazy” only applies to intermediate operations and means that they only perform work when being requested by the terminal operation. This is always the case, so when you don’t chain a terminal operation, no intermediate operation will ever process any element.

Finding out whether a terminal operation is short-circuiting, is rather easy. Go to the Stream API documentation and check whether the particular terminal operation’s documentation contains the sentence

This is a short-circuiting terminal operation.

allMatch has it, reduce has not.

This does not mean that such optimizations based on logic or algebra are impossible. But the responsibility lies at the JVM’s optimizer which might do the same for loops. However, this requires inlining of all involved methods to be sure that this conditions always applies and there are no side effect which must be retained. This behavioral compatibility implies that even if the processing gets optimized away, a peek(System.out::println) would keep printing all elements as if they were processed. In practice, you should not expect such optimizations, as the Stream implementation code is too complex for the optimizer.

Source https://stackoverflow.com/questions/70673795

QUESTION

Are any{}, all{}, and none{} lazy operations in Kotlin?

Asked 2022-Jan-12 at 01:03

I was able to do this pretty concisely like so:

class Solution {
    fun countConsistentStrings(allowed: String, words: Array<String>): Int {
      val permitted = allowed.toSet()
      return words.count{it.all{it in permitted}}
    }
}

I know that Java streams are lazy, but have read Kotlin is only lazy when asSequence is used and are otherwise eager.

For reductions to a boolean based on a predicate using any, none, or all, it makes the most sense to me that this should be done lazily (e.g. a single false in all should evaluate the whole expression to false and stop evaluating the predicate for other elements).

Are these operations implemented this way, or are they still done eagerly like other operations in Kotlin. If so, there a way to do them lazily?

ANSWER

Answered 2022-Jan-12 at 00:03

The docs don't explicitly say, but this is easy enough to test.

class A : Iterable<String>, Iterator<String> {
  public override fun iterator(): Iterator<String> {
    return this
  }
  public override fun hasNext(): Boolean {
    return true
  }
  public override fun next(): String {
    return "test"
  }
}

fun main(args: Array<String>) {
  val a = A()
  println(a.any { x -> x == "test" })
  println(a.none { x -> x == "test" })
  println(a.all { x -> x != "test" })
}

Here, A is a silly iterable class that just produces "test" forever and never runs out. Then we use any, none, and all to check whether it produces "test" or not. It's an infinite iterable, so if any of these three functions wanted to try to exhaust it, the program would hang forever. But you can run this yourself, and you'll see a true and two false's. The program terminates. So each of those three functions stopped when it found, respectively, a match, a non-match, and a non-match.

Try it online!

Source https://stackoverflow.com/questions/70674745

QUESTION

malloc a "member" of struct v.s. whole struct when struct is quite simple

Asked 2021-Sep-23 at 16:33

I have searched on this site the topics about malloc on structs. However, I have a slightly problem. Is that malloc on the element of a struct different from malloc on the whole struct, especially when that struct is quite simple, that is, only a member that is exactly what we all want to allocate? To be clear, see the code corresponding to student and student2 structs below.

struct student {
    int* majorScore;
};

struct student2 {
    int majorScore[3];
};


int main()
{
    struct student john;
    john.majorScore = (int*) malloc(sizeof(int) * 3);
    john.majorScore[0] = 50;
    john.majorScore[1] = 27;
    john.majorScore[2] = 56;
 
    struct student2* amy= (struct student2*)malloc(sizeof(struct student2));
    amy->majorScore[0] = 50;
    amy->majorScore[1] = 27;
    amy->majorScore[2] = 56;


    return 0;
}

Are they different in memory level? If yes, what is the difference? If no, which is perhaps better in terms of a good programming style?

ANSWER

Answered 2021-Sep-23 at 16:15

First, you dynamically allocate one struct, but not the other. So you're comparing apples to oranges.

Statically-allocated structs:

struct student john;
john.majorScore = malloc(sizeof(int) * 3);
john.majorScore[0] = 50;
john.majorScore[1] = 27;
john.majorScore[2] = 56;

struct student2 amy;
amy.majorScore[0] = 50;
amy.majorScore[1] = 27;
amy.majorScore[2] = 56;

struct student john
+------------+----------+      +----------+
| majorScore |         ------->|       50 |
+------------+----------+      +----------+
| [padding]  |          |      |       27 |
+------------+----------+      +----------+
                               |       56 |
                               +----------+

struct student2 amy
+------------+----------+
| majorScore |       50 |
|            +----------+
|            |       27 |
|            +----------+
|            |       56 |
+------------+----------+
| [padding]  |          |
+------------+----------+

struct student uses more memory because it has an extra value (the pointer), and it has the overhead of two memory blocks instead of one.

struct student2 always has memory for exactly three scores, even if you need fewer. And it can't possibly accommodate more than 3.

Dynamically-allocated structs:

struct student *john = malloc(sizeof(struct student));
john->majorScore = malloc(sizeof(int) * 3);
john->majorScore[0] = 50;
john->majorScore[1] = 27;
john->majorScore[2] = 56;

struct student2 *amy = malloc(sizeof(struct student2));
amy->majorScore[0] = 50;
amy->majorScore[1] = 27;
amy->majorScore[2] = 56;

struct student *john
+----------+      +------------+----------+      +----------+
|         ------->| majorScore |         ------->|       50 |
+----------+      +------------+----------+      +----------+
                  | [padding]  |          |      |       27 |
                  +------------+----------+      +----------+
                                                 |       56 |
                                                 +----------+

struct student2 *amy
+----------+      +------------+----------+
|         ------->| majorScore |       50 |
+----------+      |            +----------+
                  |            |       27 |
                  |            +----------+
                  |            |       56 |
                  +------------+----------+
                  | [padding]  |          |
                  +------------+----------+

Same analysis as above.

Source https://stackoverflow.com/questions/69303212

QUESTION

Difference between Running time and Execution time in algorithm?

Asked 2021-Aug-08 at 08:01

I'm currently reading this book called CLRS 2.2 page 25. In which the author describes the Running time of an algorithm as

The running time of an algorithm on a particular input is the number of primitive operations or “steps” executed.

Also the author uses the running time to analyze algorithms. Then I referred a book called Data Structures and Algorithms made easy by Narasimha Karumanchi. In which he describes the following.

1.7 Goal of the Analysis of Algorithms The goal of the analysis of algorithms is to compare algorithms (or solutions) mainly in terms of running time but also in terms of other factors (e.g., memory, developer effort, etc.)

1.9 How to Compare Algorithms: To compare algorithms, let us define a few objective measures:

Execution times? Not a good measure as execution times are specific to a particular computer.

Number of statements executed? Not a good measure, since the number of statements varies with the programming language as well as the style of the individual programmer.

Ideal solution? Let us assume that we express the running time of a given algorithm as a function of the input size n (i.e., f(n)) and compare these different functions corresponding to running times. This kind of comparison is independent of machine time, programming style, etc.

As you can see from CLRS the author describes the running time as the number of steps executed whereas in the second book the author says its not a good measure to use Number of step executed to analyze the algorithms. Also the running time depends on the computer (my assumption) but the author from the second book says that we cannot consider the Execution time to analyze algorithms as it totally depends on the computer.

I thought the execution time and the running time are same!

So,

What is the real meaning or definition of running time and execution time? Are they the same of different?
Does running time describe the number of steps executed or not?
Does running time depend on the computer or not?

thanks in advance.

ANSWER

Answered 2021-Aug-08 at 07:57

What is the real meaning or definition of running time and execution time? Are they the same of different?

The definition of "running time" in 'Introduction to Algorithms' by C,L,R,S [CLRS] is actually not a time, but a number of steps. This is not what you would intuitively use as a definition. Most would agree that "runnning" and "executing" are the same concept, and that "time" is expressed in a unit of time (like milliseconds). So while we would normally consider these two terms to have the same meaning, in CLRS they have deviated from that, and gave a different meaning to "running time".

Does running time describe the number of steps executed or not?

It does mean that in CLRS. But the definition that CLRS uses for "running time" is particular, and not the same as you might encounter in other resources.

CLRS assumes here that a primitive operation (i.e. a step) takes O(1) time. This is typically true for CPU instructions, which take up to a fixed maximum number of cycles (where each cycle represents a unit of time), but it may not be true in higher level languages. For instance, some languages have a sort instruction. Counting that as a single "step" would give useless results in an analysis.

Breaking down an algorithm into its O(1) steps does help to analyse the complexity of an algorithm. Counting the steps for different inputs may only give a hint about the complexity though. Ultimately, the complexity of an algorithm requires a (mathematical) proof, based on the loops and the known complexity of the steps used in an algorithm.

Does running time depend on the computer or not?

Certainly the execution time may differ. This is one of the reasons we want to by a new computer once in a while.

The number of steps may depend on the computer. If both support the same programming language, and you count steps in that language, then: yes. But if you would do the counting more thoroughly and would count the CPU instructions that are actually ran by the compiled program, then it might be different. For instance, a C compiler on one computer may generate different machine code than a different C compiler on another computer, and so the number of CPU instructions may be less on the one than the other, even though they result from the same C program code.

Practically however, this counting at CPU instruction level is not relevant for determining the complexity of an algorithm. We generally know the time complexity of each instruction in the higher level language, and that is what counts for determining the overall complexity of an algorithm.

Source https://stackoverflow.com/questions/68698460

QUESTION

Lifetime of get method in postgres Rust

Asked 2021-Jun-14 at 07:09

Some Background (feel free to skip):

I'm very new to Rust, I come from a Haskell background (just in case that gives you an idea of any misconceptions I might have).

I am trying to write a program which, given a bunch of inputs from a database, can create customisable reports. To do this I wanted to create a Field datatype which is composable in a sort of DSL style. In Haskell my intuition would be to make Field an instance of Functor and Applicative so that writing things like this would be possible:

type Env = [String]
type Row = [String]

data Field a = Field
    { fieldParse :: Env -> Row -> a }

instance Functor Field where
    fmap f a = Field $
        \env row -> f $ fieldParse a env row

instance Applicative Field where
    pure = Field . const . const
    fa <*> fb = Field $
        \env row -> (fieldParse fa) env row
            $ (fieldParse fb) env row

oneField :: Field Int
oneField = pure 1

twoField :: Field Int
twoField = fmap (*2) oneField

tripleField :: Field (Int -> Int)
tripleField = pure (*3)

threeField :: Field Int
threeField = tripleField <*> oneField

Actual Question:

I know that it's quite awkward to implement Functor and Applicative traits in Rust so I just implemented the appropriate functions for Field rather than actually defining traits (this all compiled fine). Here's a very simplified implementation of Field in Rust, without any of the Functor or Applicative stuff.

use std::result;
use postgres::Row;
use postgres::types::FromSql;

type Env = Vec<String>;

type FieldFunction<A> = Box<dyn Fn(&Env, &Row) -> Result<A, String>>;

struct Field<A> {
    field_parse: FieldFunction<A>
}

I can easily create a function which simply gets the value from an input field and creates a report Field with it:

fn field_good(input: u32) -> Field<String> {
    let f = Box::new(move |_: &Env, row: &Row| {
        Ok(row.get(input as usize))
    });

    Field { field_parse: f }
}

But when I try to make this polymorphic rather than using String I get some really strange lifetime errors that I just don't understand:

fn field_bad<'a, A: FromSql<'a>>(input: u32) -> Field<A> {
    let f = Box::new(move |_: &Env, row: &Row| {
        Ok(row.get(input as usize))
    });

    Field { field_parse: f }
}

error[E0495]: cannot infer an appropriate lifetime for autoref due to conflicting requirements
  --> src/test.rs:36:16
   |
36 |         Ok(row.get(input as usize))
   |                ^^^
   |
note: first, the lifetime cannot outlive the anonymous lifetime #2 defined on the body at 35:22...
  --> src/test.rs:35:22
   |
35 |       let f = Box::new(move |_: &Env, row: &Row| {
   |  ______________________^
36 | |         Ok(row.get(input as usize))
37 | |     });
   | |_____^
note: ...so that reference does not outlive borrowed content
  --> src/test.rs:36:12
   |
36 |         Ok(row.get(input as usize))
   |            ^^^
note: but, the lifetime must be valid for the lifetime `'a` as defined on the function body at 34:14...
  --> src/test.rs:34:14
   |
34 | fn field_bad<'a, A: FromSql<'a>>(input: FieldId) -> Field<A> {
   |              ^^
note: ...so that the types are compatible
  --> src/test.rs:36:16
   |
36 |         Ok(row.get(input as usize))
   |                ^^^
   = note: expected `FromSql<'_>`
              found `FromSql<'a>`

Any help explaining what this error is actually getting at or how to potentially fix it would be much appreciated. I included the Haskell stuff so that my design intentions are clear, that way if the problem is that I'm using a programming style that doesn't really work in Rust, then that could be pointed out to me.

EDIT: Forgot to include a link to the docs for postgres::Row::get in case it's relevant. They can be found here.

ANSWER

Answered 2021-Jun-10 at 12:54

So I seem to have fixed it, although I'm still not sure I understand exactly what I've done...

type FieldFunction<'a, A> = Box<dyn Fn(&Env, &'a Row) -> Result<A, String>>;

struct Field<'a, A> {
    field_parse: FieldFunction<'a, A>
}

fn field_bad<'a, A: FromSql<'a>>(input: u32) -> Field<'a, A> {
    let f = Box::new(move |_: &Env, row: &'a Row| {
        Ok(row.get(input as usize))
    });

    Field { field_parse: f }
}

I also swear I tried this several times before but there we are...

Source https://stackoverflow.com/questions/67920269

QUESTION

Is there a way to implement mapcar in Common Lisp using only applicative programming and avoiding recursion or iteration as programming styles?

Asked 2021-May-25 at 10:22

I am trying to learn Common Lisp with the book Common Lisp: A gentle introduction to Symbolic Computation. In addition, I am using SBCL, Emacs and Slime.

In chapter 7, the author suggests there are three styles of programming the book will cover: recursion, iteration and applicative programming.

I am interested on the last one. This style is famous for the applicative operator funcall which is the primitive responsible for other applicative operators such as mapcar.

Thus, with an educational purpose, I decided to implement my own version of mapcar using funcall:

(defun my-mapcar (fn xs)
  (if (null xs)
      nil
      (cons (funcall fn (car xs))
            (my-mapcar fn (cdr xs)))))

As you might see, I used recursion as a programming style to build an iconic applicative programming function.

It seems to work:

CL-USER> (my-mapcar (lambda (n) (+ n 1)) (list 1 2 3 4))
(2 3 4 5)

CL-USER> (my-mapcar (lambda (n) (+ n 1)) (list ))
NIL

;; comparing the results with the official one

CL-USER> (mapcar (lambda (n) (+ n 1)) (list ))
NIL

CL-USER> (mapcar (lambda (n) (+ n 1)) (list 1 2 3 4))
(2 3 4 5)

Is there a way to implement mapcar without using recursion or iteration? Using only applicative programming as a style?

Thanks.

Obs.: I tried to see how it was implemented. But it was not possible

CL-USER> (function-lambda-expression #'mapcar)
NIL
T
MAPCAR

I also used Emacs M-. to look for the documentation. However, the points below did not help me. I used this to find the files below:

/usr/share/sbcl-source/src/code/list.lisp
  (DEFUN MAPCAR)
/usr/share/sbcl-source/src/compiler/seqtran.lisp
  (:DEFINE-SOURCE-TRANSFORM MAPCAR)
/usr/share/sbcl-source/src/compiler/fndb.lisp
  (DECLAIM MAPCAR SB-C:DEFKNOWN)

ANSWER

Answered 2021-May-21 at 17:36

mapcar is by itself a primitive applicative operator (pag. 220 of Common Lisp: A gentle introduction to Symbolic Computation). So, if you want to rewrite it in an applicative way, you should use some other primitive applicative operator, for instance map or map-into. For instance, with map-into:

CL-USER> (defun my-mapcar (fn list &rest lists)
           (apply #'map-into (make-list (length list)) fn list lists))
MY-MAPCAR
CL-USER> (my-mapcar #'1+ '(1 2 3))
(2 3 4)
CL-USER> (my-mapcar #'+ '(1 2 3) '(10 20 30) '(100 200 300))
(111 222 333)

Source https://stackoverflow.com/questions/67640501

QUESTION

Create TKinter label using class method

Asked 2021-May-07 at 09:22

I am trying use object oriented programming style to write the code for a Tkinter app. I want to use a class method to place labels(or other widgets) to the GUI. The code I wrote is adding a character which I don't expect to the GUI. How can I write the initial add_label method so that it does not add the unwanted character. Below is my code and a screenshot. I am new to OOP, so i might be missing something.

from tkinter import *
class App:
    def __init__(self, parent):
        self.widgets(root)
        self.add_label(root)

    def widgets(self, app):
        self.title = Label(app, text= 'LABEL UP').pack()
        self.btn = Button(app, text = 'BUTTON').pack()
    def add_label(self, text):
        Label(text= text).pack()

root = Tk()
App(root)
App.add_label(root, 'LABEL_1')
App.add_label(root,'LABEL_2')
root.mainloop()

I am new to OOP and stil trying to figure out how i can benefit from code reuse in this case. My app has several widgets and functions

ANSWER

Answered 2021-May-07 at 09:22

What do you expect self.add_label(root) to do? According to your method definition, it takes text as argument, so when you say self.add_label(root), you are passing root as text. And what is root? It is '.', so remove it and it'll be gone.

Though a proper way to do this will be to pass a parent argument to the method and use that while widget creation:

And the important part is, your instantiating the class wrong. Keep a reference to it, rather than creating a lot of instances.

from tkinter import *

class App:
    def __init__(self, parent):
        self.widgets(root)

    def widgets(self, app):
        self.title = Label(app, text= 'LABEL UP').pack()
        self.btn = Button(app, text = 'BUTTON').pack()
    
    def add_label(self, parent, text):
        Label(parent,text= text).pack()

root = Tk()

app = App(root)
app.add_label(root, 'LABEL_1')
app.add_label(root,'LABEL_2')

root.mainloop()

Try not to get confused with both the mistakes.

How would I write this class? I don't know the true purpose of this, but I think you can follow something like this:

from tkinter import *

class App:
    def __init__(self, parent):
        self.parent = parent
        
        self.title = Label(self.parent, text='LABEL UP')
        self.title.pack()

        self.entry = Entry(self.parent)
        self.entry.pack()

        self.btn = Button(self.parent, text='BUTTON')
        # Compliance with PEP8
        self.btn.config(command=lambda: self.add_label(self.entry.get())) 
        self.btn.pack()

    def add_label(self, text):
        Label(self.parent, text=text).pack()

    def start(self):
        self.parent.mainloop()

root = Tk()

app = App(root)
app.start()

Source https://stackoverflow.com/questions/67431872

Community Discussions, Code Snippets contain sources that include Stack Exchange Network

Vulnerabilities

No vulnerabilities reported

Install glimmer-dsl-swt

Please follow these instructions to make the glimmer command available on your system via the glimmer-dsl-swt gem. If you intend to learn the basics of Glimmer but are not ready to build a Glimmer app yet, pick Option 1 (Direct Install). If you intend to build a Glimmer app from scratch with scaffolding, pick Option 1 (Direct Install) as well. Otherwise, Option 2 (Bundler) can be followed in rare cases where you want to build an app without scaffolding. Note: if you encounter any issues, please report and then install a previous version instead from the list of Glimmer Releases (keep looking back till you find one that works). Do not be disheartened as nearly everything is only a few days of work away. That said, keep in mind that this project is free and open source, meaning provided as is, so do not expect anything, but if you help with reporting and contributing, you could speed things up or even become part of the project.