Posts by Chang Park

Euclid’s Algorithm

Screen Shot 2017-10-02 at 10.32.14 PM

Euclid’s(Euclidean) Algorithm

  • Algorithm to find GCD of two large numbers

GCD(N1, N2), suppose that N1 is larger than N2

N1 = N2 * q1 + r1   <– Larger number divide by Small number

N2 = r1 * q2 + r2   <– Small number divide by remainder of previous

r1 = r2 * q3 + r3

…….

N = r * q + 0    <– When remainder becomes zero, then r is the GCD

 

example

  • GCD(1701,3768)
    • 3768 = 1701*2 + 366
    • 1701 = 366*4 + 237
    • 366 = 237*1 + 129
    • 237 = 129*1 + 108
    • 129 = 108*1 + 21
    • 108 = 21*5  + 3
    • 21 = 3*7 + 0       <– 3 is the GCD of 1701, 3768

 

Deprecated APIs

3678.deprecated

Deprecated

  • As Android Versions keep being updated, many APIs and their methods are being revised.
  • Even though those API’s methods get deprecated, developers can still use the methods. (but they will see compiler’s warning)
  • However, developers are discouraged to keep using these methods because it is dangerous or there is better alternatives.

 

Example

deprecated

 

Multi Core vs. Hyper-threading

multicore

Multi Core

  • Provides multiple cores in CPU.
  • Dual-core can run two different processes at a time. (quad-core = 4 cores = 4 processes at a time)

hyperthreading

Hyper-threading

  • Make one physical processing unit to two logical processing units.
  • Little bit of cheat to make it looks like two different processing unit.
  • Keep switching between two tasks, but actually one at a time.
  • Even though divided logically, CPU with hyper-threading performs better than CPU without hyper-threading.

 

Comparison

  • i5: 4 cores without hyper-threading => 4 processing units
  • i7: 4 cores with hyper-threading => 8 processing units(logically)

 

 

 

Diagrams are from UB CSE421 lecture slides (Professor: Karthik Dantu)

FDMA, TDMA, and CDMA

fdma

FDMA (Frequency Division Multiple Access)

  • Vary frequencies for each user.
  • If number of users increases, it becomes complicated.

TDMA (Time Division Multiple Access)

  • Using same frequency, divide into many time slots.
  • Allocating different time slot for each user.
  • They can speak only when their turns.

CDMA (Code Division Multiple Access)

  • Each pair communicates in different languages.
  • The mobile and base station are able to distinguish between signals transmitted simultaneously over the same frequency allocation.

Bandwidth and Frequency

bandwidth

Bandwidth (bps – bits per second)

  • Amount of data that can be transmitted in per unit time.
  • Difference between highest frequency and lowest frequency (bandwidth = high – low)

Frequency (Hertz)

  • Number of complete cycles per second.
    • ex) 60Hz = 60 cycles per second

bandwidth_frequency

  • Low Frequency Wave
    • There are many frequencies already being used by other appliances such as microwave ovens(causes interferences).
    • Small bandwidth: There is no much space not being used around it.
    • Too crowded these days.
    • Covers farther distance
    • Low speed
    • ex) Wifi (2.4GHz or 5 GHz)
  • High Frequency Wave
    • Large bandwidth: There is a lot of space not being used around it.
    • Covers short distance
    • High speed
    • ex) Millimeter Wave (60GHz)

 

Latency vs. Jitter

Screen Shot 2017-09-26 at 11.18.26 PM

Latency

  • Amount of time it takes for a packet to travel from point A to point B(or round-trip).
    • ex) Data Latency: time between a query and the result displaying on the screen.

Jitter

  • Variance in latency over time
  • If every packet takes exactly the same amout of time to travle from A to B, there is no jitter.

4 ways to handle button click

128

1. New OnClickListener in  setOnClickListener’s parameter

public class MainActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        Button b = (Button) findViewById(R.id.button);
        b.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Log.d("BG","1st way handling button click");
            }
        });

    }
}

2. Inner class OnClickListener

public class MainActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        Button b = (Button) findViewById(R.id.button);
        b.setOnClickListener(buttonListener);

    }

    private View.OnClickListener buttonListener = new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            Log.d("BG","2nd way handling button click");
        }
    };
}

3. Implements OnClickListener interface & override onClick()

public class MainActivity extends Activity implements View.OnClickListener {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        Button b = (Button) findViewById(R.id.button);
        b.setOnClickListener(this);

    }
    @Override
    public void onClick(View view) {
        switch(view.getId()){
            case R.id.button:
                Log.d("BG","3rd way handling button click");
                break;
        }
    }
}

4. Assign method at onClick attribute in layout file.

Activity class

public class MainActivity extends Activity implements View.OnClickListener {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
    public void buttonClick(View view) {
        Log.d("BG","4th way handling button click");
    }
}

layout file

<Button
    android:text="Button"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:id="@+id/button"
    android:onClick="buttonClick" />

 

Useful Git tips

github-mark

Apply .gitignore on already pushed repository

$ git rm -r --cached .
$ git add .
$ git commit -m '.gitignore applied'

Disconnect local repository from remote

$ git remote rm origin

 

vi Find & Replace

find_and_replace1600

Syntax

screen-shot-2016-10-20-at-12-48-14-am

Range

  • [%]
    • All lines in the file.
  • [1,30]
    • line 1 to 30
  • [5,$]
    • line 5 to last line

Pattern

  • This can be plain text and also regular expression. Combining regular expression and this command, replacing words in vi, will be powerful.
  • \<pattern\>
    • This will get the exact match, not all contained word.
This is his bag

: %s/his/her/g
=> Ther is her bag

Above command changes This also because it contains “his”.

This is his bag

: %s/\<his\>/her/g
=> This is her bag

 

Flags

  • [C]
    • Confirm each substitution
  • [g]
    • Replace all occurrence in the line
    • If you don’t put, default is just replacing first occurrence.
  • [i]
    • Ignore case for the pattern

Count

  • Do substitution in N lines from the current position of the cursor
 :s/hi/hello/g 4 

This means change all hi to hello in 4 lines from current line.

 

malloc( ) and free( )

malloc

malloc() and free()

  • allocates the requested memory and returns a pointer to it. (Dynamic memory allocation)
  • should #include<stdlib.h>
  • void *malloc(# of bytes): the function returns address of the memory.
  • void free(current_storage_pointer): de-allocate it to prevent memory leakage.

 

Example

#include<stdio.h>
#include<stdlib.h>
#include<conio.h>

int main(){
   int *p;
   p =(int *) malloc(sizeof(int));
   if(p==NULL){
      puts("Failed to allocate memory!");
   }else{
      *p = 20;
      printf("%d",*p);
      free(p);
   }
}

Example (Array)

#include<stdio.h>
#include<stdlib.h>
int main(){
   int size;
   printf("Enter the size of the array: ");
   scanf("%d", &size);
   int *a;
   a = (int *)malloc(size * sizeof(int));
   printf("\nEnter the values of the array: ");
   int i;
   for(i = 0; i < size; i++){
      scanf("%d", &a[i]);
   }
   printf("\nThe values in the array are: \n");
   for(i = 0; i < size; i++){
      printf("%d\t", a[i]);
   }
   free(a);
}