air travel – What’s the point of flight ticket cancellation charges?

Imagine a world where there were no change fees, and no cancellation fees. If you bought a ticket and then changed your mind, you could just cancel or change it. In this world, tickets would not be cheaper if you bought them in advance. After all, I could buy a ticket for a year from now then change it the day I was going to fly, and the airline would have to accommodate me. They wouldn’t get a benefit from my making firm plans in advance, so they wouldn’t motivate me with money to make my plans in advance. You probably wouldn’t like this world, because all plane tickets would cost about what “I need to fly this week” plane tickets cost today, which is about 5x what you pay if you plan far enough in advance.

Now, imagine the same world with no change fees or cancellations, but with no refunds either. You buy a ticket, use it or not, we don’t care, but it’s paid for. A bit like putting a subway token in a turnstile but then not going through. You wouldn’t like this world either: plans do change and people don’t want to lose all the money they paid for a plane ticket. Travel insurance exists, but doesn’t cover everything.

So, ok, the airline is going to charge you some money to change or cancel your plans. There are two ways to establish that charge. One is “what does it cost them” which is a few pennies in IT stuff and then possibly thousands in switching to a bigger plane for the route or whatever. That’s too much of a lottery for passengers to take on. A sort of average charge of a few hundred might be fairer. But the other approach is “what will deter this behaviour?” If changes cost hundreds, you won’t book until you’re really very sure you going to do it. (Example: I book hotel rooms for events I might or might not attend, since they book up fast and can be cancelled no charge. I don’t buy the plane tickets until I know for sure I’m going.)

Then on top of that you have to think about the system-gamers. You fly once or twice a year. But there are people who fly every week. And they want to get upgraded, they want maximum status miles, they want to be home half an hour earlier than they would normally be, and all kinds of things that aren’t an option for you or don’t matter for you. They invest time and energy into gaming systems. They book three flights from A to B on the same day, so they can decide on the day which one they want and that’s cheaper than buying a last minute ticket on the day. They do “nested returns” and “hidden cities” and a ton of things you’d never do. The fees have to be robust against that kind of nonsense too.

So what this adds up to is that fees must exist, mostly to control your behaviour and make your plans firmer, so that they can plan their staff and equipment usage properly. Sometimes it seems like they would do better if they didn’t charge you that fee — but that’s because you haven’t thought about how to game that if you fly that route every single week.

geometry – Sum of distances from a point inside triangle(stronger version)

In the figure prove that $$min(OR,PR,QR)+OR+PR+QR<OQ+QP+PO$$enter image description here


This is a stronger form of the inequality $OR+PR+QR<OQ+QP+PO$ that can be easily proven.I have made some constructions in the above figure.From that we can write $$ frac{RU}{OU}+frac{RS}{QS}+frac{RT}{PT} =1$$ I also have tried to use the fact $$RU<max(RP,RQ),SR<max(OR,RP) …$$

Any ideas

mathematics – Rotate relative to set point in a specified direction in a 3D space

I know there’s a geometry formula to calculate the next point in rotation relative to another point in 2D but I’m working in 3D and I want to calculate the next position in specified direction as well. Think Spiderman or the Bloodstalkers from ARK. I’m working in a game engine that uses the basic {x = 1, y = 2, z = 1} for vectors. I’m pretty bad at math so I honestly can’t figure this out myself.

I Will Create 300 Google Map Point Citation for local business seo for $5

I Will Create 300 Google Map Point Citation for local business seo

Hi,

I will build Rank First on Google map for your local business.Local Map citation help to boost Google place ranking Top Google and local business in online.The work is a power house of link-juice for your local SEO.I have been working in the industry from the past 5 years.

My Gig Service?

Manual work

Google Rank Seo Service

Google Ranking Map Citation

Ranking in Search Engine Results.

We offer a customer satisfaction guarantee.

Very fast super delivery

100% Map Citations.

No Spam

Your Business address show up in Maps.

A good support of 24/7

I Need Your From,

Company/ Business Name

Website

Address

City, State, Zip Code

Keywords

category

Description

Phone Number

I will give always Rank First Google High Quality SEO Service.

Thanks…

.

python – How to load a new map when player reaches a certain point using if tile_object.name == ‘door” (pygame)

I have been working on creating a 2d game, and I am now at the point where I want the character to be able to interact with his environment, I have created a few different obstacles such as a house, fence and a wall is it possible to load a new map when the player reached the tile named “door” I have it written out as if tile_object.name == ‘door’: but not sure what to load after that so that a new map loads when he reaches that obstacle named door any help would be greatly appreciated 🙂 I have attached my code below for main.py

import pygame as pg
import sys
from os import path
from settings import *
from sprites import *
from tilemap import *

class Game:
def init(self):
pg.init()
self.screen = pg.display.set_mode((WIDTH, HEIGHT))
pg.display.set_caption(TITLE)
self.clock = pg.time.Clock()
self.running = True
self.font_name = pg.font.match_font(FONT_NAME)
self.bg_img = pg.image.load(‘background.jpg’)
self.load_data()

def load_data(self):
    game_folder = path.dirname(__file__)
    img_folder = path.join(game_folder, 'img')
    map_folder = path.join(game_folder, 'maps')
    self.map = TiledMap(path.join(map_folder, 'map2use.tmx'))
    self.map_img = self.map.make_map()
    self.map_rect = self.map_img.get_rect()
    self.spritesheet = Spritesheet(path.join(img_folder, SPRITESHEET))
    self.mob_img = pg.image.load(path.join(img_folder, MOB_IMG)).convert_alpha()
    self.snd_dir = path.join(game_folder, 'snd')

def load_data2(self):
    game_folder = path.dirname(__file__)
    img_folder = path.join(game_folder, 'img')
    map_folder = path.join(game_folder, 'maps')
    self.map = TiledMap_2(path.join(map_folder, 'map3use.tmx'))
    self.map_img = self.map.make_map2()
    self.map_rect = self.map_img.get_rect()
    self.spritesheet = Spritesheet(path.join(img_folder, SPRITESHEET))

def new(self):
    self.all_sprites = pg.sprite.Group()
    self.mobs = pg.sprite.Group()
    self.walls = pg.sprite.Group()
    pg.mixer.music.load(path.join(self.snd_dir, "midnight_drive.ogg"))
    for tile_object in self.map.tmxdata.objects:
        if tile_object.name == 'player':
            self.player = Player(self, tile_object.x, tile_object.y)
        if tile_object.name == "enemy":
            Mob(self, tile_object.x, tile_object.y)
        if tile_object.name == 'Wall':
            Obstacle(self, tile_object.x, tile_object.y, tile_object.width, tile_object.height)
        if tile_object.name == 'tree':
            Obstacle(self, tile_object.x, tile_object.y, tile_object.width, tile_object.height)
        if tile_object.name == 'house':
            Obstacle(self, tile_object.x, tile_object.y, tile_object.width, tile_object.height)
        if tile_object.name == 'fence':
            Obstacle(self, tile_object.x, tile_object.y, tile_object.width, tile_object.height)
        if tile_object.name == 'door':
            Obstacle(self, tile_object.x, tile_object.y, tile_object.width, tile_object.height)

    self.camera = Camera(self.map.width, self.map.height)
    self.draw_debug = False
    self.run()

def run(self):
    self.playing = True
    pg.mixer.music.play(loops=-1)
    while self.playing:
        self.dt = self.clock.tick(FPS) / 1000
        self.events()
        self.update()
        self.draw()
    pg.mixer.music.fadeout(500)

def quit(self):
    pg.quit()
    sys.exit()

def update(self):
    self.all_sprites.update()
    self.camera.update(self.player)
    #mob spawn
    
def draw_grid(self):
    for x in range(0, WIDTH, TILESIZE):
        pg.draw.line(self.screen, LIGHTGREY, (x, 0), (x, HEIGHT))
    for y in range(0, HEIGHT, TILESIZE):
        pg.draw.line(self.screen, LIGHTGREY, (0, y), (WIDTH, y))

def draw(self):
    pg.display.set_caption('{:.2f}'.format(self.clock.get_fps()))
    self.screen.blit(self.map_img, self.camera.apply_rect(self.map_rect))
    for sprite in self.all_sprites:
        self.screen.blit(sprite.image, self.camera.apply(sprite))
        if self.draw_debug:
            pg.draw.rect(self.screen, CYAN, self.camera.apply_rect(sprite.hit_rect), 1)
    if self.draw_debug:
        for wall in self.walls:
            pg.draw.rect(self.screen, CYAN, self.camera.apply_rect(wall.rect), 1)

    pg.display.flip()

def events(self):
    for event in pg.event.get():
        if event.type == pg.QUIT:
            self.quit()
        if event.type == pg.KEYDOWN:
            if event.key == pg.K_ESCAPE:
                self.quit()
            if event.key == pg.K_h:
                self.draw_debug = not self.draw_debug

def show_start_screen(self):
    # game splash/start screen
    #self.screen.fill(BGCOLOR)
    pg.mixer.music.load(path.join(self.snd_dir, "Feat.ogg"))
    pg.mixer.music.play(loops=-1)
    self.screen.blit(self.bg_img, self.bg_img.get_rect())
    pg.display.flip()
    self.wait_for_key()
    pg.mixer.music.fadeout(500)

def show_go_screen(self):
    # game over/continue
    if not self.running:
        return
    #self.screen.fill(BGCOLOR)
    self.screen.blit(self.bg_img, self.bg_img.get_rect())
    pg.display.flip()
    self.wait_for_key()

def wait_for_key(self):
    waiting = True
    while waiting:
        self.clock.tick(FPS)
        for event in pg.event.get():
            if event.type == pg.QUIT:
                waiting = False
                self.running = False
            if event.type == pg.KEYUP:
                waiting = False

def draw_text(self, text, size, color, x, y):
    font = pg.font.Font(self.font_name, size)
    text_surface = font.render(text, True, color)
    text_rect = text_surface.get_rect()
    text_rect.midtop = (x, y)
    self.screen.blit(text_surface, text_rect)

g = Game()
g.show_start_screen()
while True:
g.new()
g.run()
g.show_go_screen()

I have an old 2012 Macbook Pro 13in. At what point will I stop getting macOS updates?

I have an old 2012 Macbook Pro 13in. At what point will I stop getting macOS updates?

According to How-to Geek

enter image description here

Currently, my Macbook uses macOS Catalina. If I don’t get Big Sur, will I continue to get security updates from Apple in perpetuity? or does it mean I have to scrap my Mac in a few years because it’s not patched for new security vulnerabilities? Thank you!

database design – Modeling a Fact Table for Data that Changes Grain at one Point in Time

I am in the process of building a data warehouse data model for a data set, lets call it SALES, which spans in time from 2006 to present.

The problem:

The grain is consistent throughout except for one point, near the middle, where an additional dimension was added in.

Example:

Here’s a simplified example that illustrates what I mean:

THE_DATE    CATEG   REGION  SALES
--------    -----   ------  -----
2006-01-01  shoes   NULL    233.00
2006-01-01  Hats    NULL     46.00
2006-01-01  Shirts  NULL    857.00
...
2013-01-01  shoes   Eastern 823.00
2013-01-01  shoes   Western 123.00
2013-01-01  Hats    Eastern 16.00
2013-01-01  Hats    Western 27.00
2013-01-01  Shirts  Eastern 457.00
2013-01-01  Shirts  Western 356.00

Some additional notes:

  • We’re interested in the new dimension (e.g. we don’t want to simply ignore that dimension and aggregate measures)
  • There’s no way we can interpolate / allocate earlier values across the new dimension.
  • Need to be able to report on sales over the full time period.
  • Data is from a third party, and nothing can be done to change the grain at the source.

Possible Option:

One option is that I could include the REGION dimension key in the FACT table, and leave the REGION_KEY = -1 (which maps to an “Undefined” row in REGION_DIM, but that comes with it’s obvious disadvantages e.g. new users might not realize the issue, etc. But this might be the option I have to go with.

Questions:

  1. Are there other disadvantages to the option above? (single fact table, include the REGION dimension)
  2. Are there any other ways in which this can be handled when modeling the target FACT table that might have fewer drawbacks?

conic sections – Prove that the normals at A, B, C incribed in $xy=c^2$ will meet in a point if $cot2alpha + cot2beta + cot 2gamma = 0$

The sides of a triangle ABC, inscribed in a hyperbola $xy = c^2$, makes angles $alpha, beta, gamma $ with an asymptote.

Prove that the normals at A, B, C will meet in a point if $cot2alpha + cot2beta + cot 2gamma = 0$

My approach: Assuming $A left(ct_1,frac{c}{t_1}right), B left(ct_2,frac{c}{t_2}right) and C left(ct_3,frac{c}{t_3}right)$, we can work out $t_1t_2=-cotalpha$ and so on

Equation of a normal to rectangular hyperbola is $t^3x-ty=ct^4-c$ which is fourth degree equation which doesn’t help the cause. Using determinants for concurrency doesn’t yield any fruitful results.

unity – ScreenToWorldPoint: How much depth has to be added to screen point?

I am developing a 3rd Person Controller.

The hero’s chest should be rotated towards a point on the screen.

To determine the point, I use the following code:

var mousePos = Input.mousePosition;
mousePos.z = 10; // Make sure to add some "depth" to the screen point 

var aim = Camera.main.ScreenToWorldPoint(mousePos);

Then I rotate the chest like this:

Vector3 v = new Vector3(0, aim.x, 0);
Chest.Rotate(v);

It does work, but it rotates only minimally, and the the direction is inverted: If the mouse is on the right of the screen, the chest rotates to the left and vice versa.

Also, I’m not sure how to include the model’s overall rotation (but I don’t know yet if that is necessary).

Does anybody have any idea what I’m doing wrong?

Edit:
When I add more depth to it, it rotates much more:

var mousePos = Input.mousePosition;
mousePos.z = 100; // Make sure to add some "depth" to the screen point 

var aim = Camera.main.ScreenToWorldPoint(mousePos);

But I have no idea how much depth is actually needed.
If I add 1000, it rotates like crazy.

So I would like to know how to calculate the amount of depth that should actually be added to the screen point.